/*
 * 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 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;

            protected:
                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);

            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;

                // TODO: Consider asbtracting to the ICellularRadio::getFirmwareBuild
                //!< Get Quectel-specific firmware version (firmware build?)
                CODE getQuectelFirmware(std::string& sFirmware);

                CODE startFileUpload(const std::string& sTargetFilename, size_t nBytes);
                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);
                static CODE getFileSize(int fd, size_t& nBytes, size_t& nFileChunks);
                static CODE readChunk(int fd, char* pChunk, size_t dChunkSize, size_t& nReadBytes);
                CODE fumoWaitUpgradeFinished(UpdateCb& stepCb);
                CODE fumoWaitNewFirmware(UpdateCb& stepCb);
        };
    }
}

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_ */