#ifndef MTS_IO_ICELLULARRADIO_H
#define MTS_IO_ICELLULARRADIO_H

#include <string>
#include <vector>
#include <functional>

#include <json/json.h>

#include <mts/MTS_AutoPtr.h>
#include <mts/MTS_IO_Connection.h>

namespace MTS {
    namespace IO {
        class ICellularRadio;
        namespace {

            static const std::string DEFAULT_RADIO_PORT;
            static const std::string DEFAULT_RADIO_DIR;

            static const std::string VALUE_UNKNOWN;
            static const std::string VALUE_UNAVAILABLE;
            static const std::string VALUE_NOT_SUPPORTED;

            //Special Payload Characters
            static const char ETX = 0;  //Ends socket connection
            static const char DLE = 0;  //Escapes ETX and DLE within Payload
            static const char CR = 0;
            static const char NL = 0;
            static const char CTRL_Z = 0;

            static const std::string RSP_OK;
            static const std::string RSP_ERROR;

            static const std::string VALUE_NOT_REGISTERED;
            static const std::string VALUE_REGISTERED;
            static const std::string VALUE_SEARCHING;
            static const std::string VALUE_DENIED;
            static const std::string VALUE_ROAMING;

            //Static Data
            static const std::string KEY_TYPE;          //!< GSM or CDMA
            static const std::string KEY_CODE;          //!< Product Code : H5, H6, C2, EV3, G3
            static const std::string KEY_MODEL;         //!< Model : HE910, CE910, DE910, GE910
            static const std::string KEY_MANUFACTURER;  //!< Manufacturer: Telit
            static const std::string KEY_HARDWARE;      //!< Radio Hardware Version
            static const std::string KEY_FIRMWARE;      //!< Radio Firmware Version
            static const std::string KEY_FIRMWARE_BUILD;//!< Radio Firmware Build
            static const std::string KEY_IMEI;          //!< International Mobile Station Equipment Identity
            static const std::string KEY_MEID;          //!< Mobile Equipment Identifier
            static const std::string KEY_IMSI;          //!< International Mobile Subscriber Identity
            static const std::string KEY_MSID;          //!< Mobil Station ID (MSID) aka MIN aka MSIN aka Last few digits of IMSI
            static const std::string KEY_MDN;           //!< Mobile Directory Number : Actual phone number dialed to reach radio
            static const std::string KEY_CARRIER;       //!< Cellular Service Provider (Home Network)
            static const std::string KEY_ICCID;         //!< Integrated Circuit Card Identifier
            static const std::string KEY_MSL;           //!< Master Subsidy Lock


            //Network Status Data
            static const std::string KEY_ROAMING;       //!< Indicates whether or not using Home Network
            static const std::string KEY_DATETIME;      //!< Date and Time from tower
            static const std::string KEY_SERVICE;       //!< Service Connection Type [GPRS, EGPRS, WCDMA, HSDPA, 1xRTT, EVDO]
            static const std::string KEY_NETWORK;       //!< Cellular Service Provider
            static const std::string KEY_NETWORK_REG;   //!< Network Registration
            static const std::string KEY_CID;           //!< Cellular ID (Tower) in HEX
            static const std::string KEY_LAC;           //!< Location Area Code in HEX
            static const std::string KEY_RAC;           //!< Routing Area Code in HEX
            static const std::string KEY_RSSI;          //!< Received Signal Strength Indication
            static const std::string KEY_RSSIDBM;       //!< Received Signal Strength Indication in dBm
            static const std::string KEY_MCC;           //!< Mobile Country Code
            static const std::string KEY_MNC;           //!< Mobile Network (Operator) Code
            static const std::string KEY_CHANNEL;       //!< ARFCN or UARFCN Assigned Radio Channel
            static const std::string KEY_TXPWR;         //!< Transmit Power
            static const std::string KEY_PSC;           //!< Active Primary Synchronization Code (PSC)
            static const std::string KEY_ECIO;          //!< Active Ec/Io (chip energy per total wideband power in dBm)
            static const std::string KEY_RSCP;          //!< Active RSCP (Received Signal Code Power in dBm)
            static const std::string KEY_DRX;           //!< Discontinuous reception cycle length (ms)
            static const std::string KEY_MM;            //!< Mobility Management State
            static const std::string KEY_RR;            //!< Radio Resource State
            static const std::string KEY_NOM;           //!< Network Operator Mode
            static const std::string KEY_ABND;          //!< Active Band
            static const std::string KEY_BLER;          //!< Block Error Rate (percentage)
            static const std::string KEY_SD;            //!< Service Domain
            static const std::string KEY_DEBUG;         //!< Debug Information

            static const std::string KEY_MIP;                //!< Mobile IP Information
            static const std::string KEY_MIP_ID;             //!< MIP Profile ID
            static const std::string KEY_MIP_ENABLED;         //!< MIP Profile Enabled/Disabled
            static const std::string KEY_MIP_NAI;            //!< Network Access Identifier
            static const std::string KEY_MIP_HOMEADDRESS;    //!< Home Address
            static const std::string KEY_MIP_PRIMARYHA;      //!< Primary Home Agent
            static const std::string KEY_MIP_SECONDARYHA;    //!< Secondary Home Agent
            static const std::string KEY_MIP_MNAAASPI;       //!< Mobile Node Authentication, Authorization, and Accounting Server Security Parameter Index
            static const std::string KEY_MIP_MNHASPI;        //!< Mobile Node Home Agent Security Server Parameter Index
            static const std::string KEY_MIP_REVTUN;         //!< Reverse Tunneling Enabled
            static const std::string KEY_MIP_MNAAASS;        //!< Mobile Node Authentication, Authorization, and Accounting Server Shared Secret
            static const std::string KEY_MIP_MNHASS;         //!< Mobile Node Home Agent Shared Secret


            //Values - Type
            static const std::string VALUE_TYPE_LTE;
            static const std::string VALUE_TYPE_GSM;
            static const std::string VALUE_TYPE_CDMA;

            //Values - Carrier
            static const std::string VALUE_CARRIER_VERIZON;
            static const std::string VALUE_CARRIER_AERIS;
            static const std::string VALUE_CARRIER_SPRINT;
            static const std::string VALUE_CARRIER_USCELLULAR;
            static const std::string VALUE_CARRIER_ATT;
            static const std::string VALUE_CARRIER_TMOBILE;

            static const std::string VALUE_SD_NO_SERVICE;
            static const std::string VALUE_SD_CS_ONLY;
            static const std::string VALUE_SD_PS_ONLY;
            static const std::string VALUE_SD_CSPS;

            static const std::string VALUE_ABND_GSM_850;
            static const std::string VALUE_ABND_GSM_900;
            static const std::string VALUE_ABND_DCS_1800;
            static const std::string VALUE_ABND_PCS_1900;

            static const std::vector<std::string> DEFAULT_BAIL_STRINGS;

            typedef std::function<bool(const std::string&/*iterationData*/, const std::string&/*allData*/)> IsNeedMoreData;
            typedef std::function<void(const Json::Value&)> UpdateCb;

            /*
            CODE convertModelToType(const std::string& sModel, std::string& sType);
            CODE convertModelToMtsShortCode(const std::string& sModel, std::string& sCode, ICellularRadio *radioObj = NULL);
            CODE convertServiceDomainToString(SERVICEDOMAIN eSd, std::string& sSd);
            CODE convertActiveBandToString(ACTIVEBAND eBand, std::string& sBand);

            std::string sendCommand(MTS::AutoPtr<MTS::IO::Connection>& apIo,
                                    const std::string& sCmd,
                                    IsNeedMoreData& isNeedMoreData,
                                    int32_t timeoutMillis = 100,
                                    const char& ESC = CR);

            std::string sendCommand(MTS::AutoPtr<MTS::IO::Connection>& apIo,
                                    const std::string& sCmd,
                                    const std::vector<std::string>& vBail = DEFAULT_BAIL_STRINGS,
                                    int32_t timeoutMillis = 100,
                                    const char& ESC = CR);
            CODE test(MTS::AutoPtr<MTS::IO::Connection>& apIo, uint32_t timeoutSeconds = 30);

            std::string extractModelFromResult(const std::string& sResult);
            std::string getCodeAsString(CODE code);
            */

        }
        class ICellularRadio
        {
            public:
                //Registration Values
                enum REGISTRATION : uint8_t {
                    NOT_REGISTERED = 0,
                    REGISTERED = 1,
                    SEARCHING=2,
                    DENIED=3,
                    UNKNOWN=4,
                    ROAMING=5
                };

                enum SERVICEDOMAIN : uint8_t {
                    NO_SERVICE = 0,
                    CS_ONLY = 1,
                    PS_ONLY = 2,
                    CSPS = 3
                };

                enum ACTIVEBAND : uint8_t {
                    GSM_850 = 0,
                    GSM_900 = 1,
                    DCS_1800 = 2,
                    PCS_1900 = 3
                };

                enum CODE : uint8_t {
                    SUCCESS = 0,
                    ERROR,
                    FAILURE,
                    NO_RESPONSE,
                    NOT_APPLICABLE,
                    INVALID_ARGS
                };

                enum SIMSTATUS : uint8_t {
                    READY = 0,
                    LOCKED,
                    BLOCKED,
                    NOT_INSERTED
                };
                virtual ~ICellularRadio() = 0;

                virtual bool initialize(uint32_t iTimeoutMillis = 5000) = 0;
                virtual bool resetRadio(uint32_t iTimeoutMillis = 5000) = 0;
                virtual bool resetConnection(uint32_t iTimeoutMillis = 5000) = 0;
                virtual void shutdown() = 0;

                virtual const std::string& getName() const = 0;

                virtual CODE getModel(std::string& sModel) = 0;

                virtual CODE getFirmware(std::string& sFirmware) = 0;
                virtual CODE getFirmwareBuild(std::string& sFirmwareBuild) = 0;
                virtual CODE getHardware(std::string& sHardware) = 0;
                virtual CODE getManufacturer(std::string& sManufacturer) = 0;
                virtual CODE getImei(std::string& sImei) = 0;
                virtual CODE getMeid(std::string& sMeid) = 0;
                virtual CODE getImsi(std::string& sImsi) = 0;
                virtual CODE getSimStatus(std::string& sSimStatus) = 0;
                virtual CODE getIccid(std::string& sIccid) = 0;
                virtual CODE getService(std::string& sService) = 0;
                virtual CODE getLac(std::string& sLac) = 0;
                virtual CODE getMdn(std::string& sMdn) = 0;
                virtual CODE getMsid(std::string& sMsid) = 0;
                virtual CODE getType(std::string& sType) = 0;
                virtual CODE getCarrier(std::string& sCarrier) = 0;
                virtual CODE getNetwork(std::string& sNetwork) = 0;
                virtual CODE getTower(std::string& sTower) = 0;
                virtual CODE getTime(std::string& sDate, std::string& sTime, std::string& sTimeZone) = 0;
                virtual CODE getRoaming(bool& bRoaming) = 0;

                virtual CODE getSignalStrength(int32_t& iRssi) = 0;
                virtual CODE getModemLocation(std::string& sLocation) = 0;
                virtual CODE convertSignalStrengthTodBm(const int32_t& iRssi, int32_t& dBm) = 0;
                virtual CODE convertdBmToSignalStrength(const int32_t& dBm, int32_t& iRssi) = 0;

                virtual CODE getRegistration(REGISTRATION& eRegistration) = 0;
                virtual CODE convertRegistrationToString(REGISTRATION eRegistration, std::string& sRegistration) = 0;

                //! Gather details of the radio's Mobile IP Profile
                /*!
                 \param Json::Value object that will be populated with MIP data
                 \return Returns result code of gathering MIP
                 */
                virtual CODE getMipProfile(Json::Value& jMipProfile) = 0;

                /*
                 * jArgs = {
                 *     "msl" : "Master Subsidy Lock (Aeris, Sprint): STRING"
                 * }
                 */
                virtual CODE validateMsl(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "mdn" : "Mobile Directory Number : STRING",
                 *     "msl" : "[OPTIONAL] Master Subsidy Lock (Aeris, Sprint): STRING"
                 * }
                 */
                virtual CODE setMdn(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "msid" : "Mobil Station ID (MSID) aka MIN aka MSIN : STRING",
                 *     "msl" : "[OPTIONAL] Master Subsidy Lock (Aeris, Sprint): STRING"
                 * }
                 */
                virtual CODE setMsid(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "activeProfile" : "Set active profile: STRING"
                 * }
                 */
                virtual CODE setMipActiveProfile(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "nai" : "Network Access Identifier : STRING"
                 * }
                 */
                virtual CODE setMipNai(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "homeIp" : "Home Address : STRING"
                 * }
                 */
                virtual CODE setMipHomeIp(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "primaryHa" : "Primary Home Agent : STRING"
                 * }
                 */
                virtual CODE setMipPrimaryHa(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "secondaryHa" : "Secondary Home Agent : STRING"
                 * }
                 */
                virtual CODE setMipSecondaryHa(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "mnAaaSpi" : "Mobile Node Authentication, Authorization, and Accounting Server Security Parameter Index : STRING"
                 * }
                 */
                virtual CODE setMipMnAaaSpi(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "mnHaSpi" : "Mobile Node Home Agent Security Server Parameter Index : STRING"
                 * }
                 */
                virtual CODE setMipMnHaSpi(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "revTun" : "[DESCRIPTION] : STRING"
                 * }
                 */
                virtual CODE setMipRevTun(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "mnAaaSs" : "Mobile Node Authentication, Authorization, and Accounting Server Shared Secret : STRING"
                 * }
                 */
                virtual CODE setMipMnAaaSs(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = {
                 *     "mnHaSs" : "Mobile Node Home Agent Shared Secret : STRING"
                 * }
                 */
                virtual CODE setMipMnHaSs(const Json::Value& jArgs) = 0;

                /*
                 * jArgs = null
                 */
                virtual CODE updateDc(const Json::Value& jArgs, UpdateCb& stepCb) = 0;

                /*
                 * jArgs = null
                 */
                virtual CODE updatePrl(const Json::Value& jArgs, UpdateCb& stepCb) = 0;

                /*
                 * jArgs = null
                 */
                virtual CODE updateFumo(const Json::Value& jArgs, UpdateCb& stepCb) = 0;

                /*
                 * jArgs = {
                 *     "msl" : "Master Subsidy Lock (Sprint): STRING"
                 * }
                 */
                virtual CODE resetHfa(const Json::Value& jArgs, UpdateCb& stepCb) = 0;

                /*
                 * jArgs = {
                 *     "mdn" : "Mobile Directory Number (Aeris): STRING"
                 *     "msid" : "Mobile Station ID (Aeris): STRING"
                 * }
                 */
                virtual CODE activate(const Json::Value& jArgs, UpdateCb& stepCb) = 0;

                /*
                 * jArgs = {
                 *     "enabled" : "RX Diversity Enabled ("0" or "1"): STRING"
                 * }
                 */
                virtual CODE setRxDiversity(const Json::Value& jArgs) = 0;
                /*
                 * jArgs = {
                 *     "fwid" : "Firmware Image To Be Enabled: STRING"
                 * }
                 */
                virtual CODE setActiveFirmware(const Json::Value& jArgs) = 0;
                virtual CODE getActiveFirmware(std::string& sFwId) = 0;

                virtual CODE getEcho(bool& bEnabled) = 0;
                virtual CODE setEcho(bool bEnabled = true) = 0;

                virtual CODE getStaticInformation(Json::Value& jData) = 0;
                virtual CODE getNetworkStatus(Json::Value& jData) = 0;

                virtual CODE sendBasicCommand(const std::string& sCmd, int32_t timeoutMillis = 100, const char& ESC = CR) = 0;

                virtual std::string sendCommand(const std::string& sCmd,
                                                const std::vector<std::string>& vBail = DEFAULT_BAIL_STRINGS,
                                                int32_t timeoutMillis = 100,
                                                const char& ESC = CR) = 0;

                virtual std::string sendCommand(const std::string& sCmd,
                                                IsNeedMoreData& isNeedMoreData,
                                                int32_t timeoutMillis = 100,
                                                const char& ESC = CR) = 0;

        };
    }
}

#endif