/*
 * Copyright (C) 2019 by Multi-Tech Systems
 *
 * This file is part of libmts-io.
 *
 * libmts-io is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * libmts-io is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libmts-io.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef MTS_IO_QUECTELRADIO_H_
#define MTS_IO_QUECTELRADIO_H_

#include <mts/MTS_IO_CellularRadio.h>

namespace MTS {
    namespace IO {

        class QuectelRadio : public CellularRadio {

            public:
                bool resetRadio(uint32_t iTimeoutMillis = 5000) override;

                CODE getVendorFirmware(std::string& sVendorFirmware) override;
                CODE getModel(std::string& sModel) override;
                CODE getIccid(std::string& sIccid) override;
                CODE getService(std::string& sService) override;
                CODE getNetwork(std::string& sNetwork) override;
                CODE getNetworkStatus(Json::Value& jData) override;

                CODE convertSignalStrengthTodBm(const int32_t& iRssi, int32_t& dBm) override;
                CODE convertdBmToSignalStrength(const int32_t& dBm, int32_t& iRssi) override;

                CODE setMdn(const Json::Value& jArgs) override;
                CODE startOmaDm(ICellularRadio::UpdateCb& stepCb) override;

                CODE setCellularMode(CELLULAR_MODES networks) override;

                CODE updateFumoLocal(int fd, UpdateCb& stepCb) override;
                CODE fumoLocalInject(int fd, UpdateCb& stepCb) override;
                CODE fumoLocalCleanup() override;
                CODE fumoLocalApply(UpdateCb& stepCb) override;

                CODE setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION mode) override;
                CODE getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& mode) override;

            protected:
                enum class UE_USAGE_SETTING : uint8_t {
                    UNKNOWN_MODE = 0, // Unknown mode
                    MODE_1, // Voice centric mode
                    MODE_2 // Data centric mode
                };

                QuectelRadio(const std::string& sName, const std::string& sRadioPort);

                CODE getIsSimInserted(bool& bData) override;
                CODE getSimLockAttempts(int& iAttemptsPin, int& iAttemptsPuk) override;

                virtual CODE getServiceDomain(SERVICEDOMAIN& sd);
                virtual CODE convertToActiveBand(const std::string& sQuectelBand, ACTIVEBAND& band);

                virtual CODE uploadFile(int fd, const std::string& sTargetFilename, UpdateCb& stepCb);
                virtual CODE removeFile(const std::string& sTargetFilename);
                virtual CODE checkFile(bool& bFilePresent, const std::string& sTargetFilename);

                virtual CODE getUeUsageSetting(QuectelRadio::UE_USAGE_SETTING& us);
                virtual CODE convertToUeUsageSetting(const std::string& sSetting, QuectelRadio::UE_USAGE_SETTING& us);

            private:
                // private variable to save old firmware versions during FOTA
                std::string m_sQuectelFirmware;

                static const size_t FILE_CHUNK_SIZE;
                static const std::string CMD_ABORT_UPLOAD;
                static const std::string VALUE_MTS_DELTA_NAME;
                static const std::string VALUE_MTS_DELTA_PATH;

                CODE startFileUpload(const std::string& sTargetFilename, size_t nBytes, uint16_t uRxTimeout = 5, bool bAckEnabled = false);
                CODE abortFileUpload();

                static inline void callNextStep(UpdateCb& stepCb, const char* csMessage);
                static inline void callNextStep(UpdateCb& stepCb, const std::string& sMessage);

                static uint16_t getQuectelChecksum(const void* data, size_t nBytes);
                static inline void updateQuectelChecksum(uint16_t& iChecksum, uint16_t iNewFragment);
                static inline uint16_t bytesToUint16(uint8_t high, uint8_t low);

                CODE fumoWaitUpgradeFinished(UpdateCb& stepCb);
                CODE fumoWaitNewFirmware(UpdateCb& stepCb);

                /// Parse error code if +QIND: "FOTA" received before the first attempt to flash the firmware
                std::string getFumoEarlyErrorCode(const std::string& sRadioInput);

                /// Get value from container by its index, use default value if not found. Non-template version.
                const std::string& getByIndex(const std::vector<std::string>& vector, size_t index, const std::string& defaultValue) {
                    if (index >= vector.size()) {
                        return defaultValue;
                    } else {
                        return vector[index];
                    }
                }
        };
    }
}

void MTS::IO::QuectelRadio::callNextStep(ICellularRadio::UpdateCb& stepCb, const char* csMessage) {
    if (stepCb) {
        stepCb(Json::Value(csMessage));
    }
}

void MTS::IO::QuectelRadio::callNextStep(ICellularRadio::UpdateCb& stepCb, const std::string& sMessage) {
    if (stepCb) {
        stepCb(Json::Value(sMessage));
    }
}

void MTS::IO::QuectelRadio::updateQuectelChecksum(uint16_t& iChecksum, uint16_t iNewFragment) {
    iChecksum = iChecksum ^ iNewFragment;
}

uint16_t MTS::IO::QuectelRadio::bytesToUint16(uint8_t high, uint8_t low) {
    uint16_t comboHigh = static_cast<uint16_t>(high << 8);  // explicit cast to prevent warnings
    uint16_t comboLow = low;
    return (comboHigh | comboLow);
}

#endif /* MTS_IO_QUECTELRADIO_H_ */