/*
 * Copyright (C) 2015 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/>.
 *
 */

/*! 
 \file MTS_IO_LE910Radio.cpp
 \brief A brief description 
 \date Nov 6, 2014
 \author sgodinez

 A more elaborate description
*/

#include <mts/MTS_IO_LE910Radio.h>
#include <mts/MTS_Logger.h>
#include <mts/MTS_Text.h>

using namespace MTS::IO;

LE910Radio::LE910Radio(const std::string& sLE910Model, const std::string& sPort)
: TelitRadio(sLE910Model, sPort)
{

}

ICellularRadio::CODE LE910Radio::setRxDiversity(const Json::Value& jArgs) {
/* Command string for LAT1,LVW2,LEU1 radios:  "AT#RXDIV=" */
/* Setting needs to append ",1" to the 0/1 value */
        if (jArgs["enabled"].asString() != "1" && jArgs["enabled"].asString() != "0")
        {
                return FAILURE;
        }
        std::string sCmd = "AT#RXDIV=";
        sCmd += jArgs["enabled"].asString();
        sCmd += ",1";

        return sendBasicCommand(sCmd);
}

ICellularRadio::CODE LE910Radio::getModemLocation(std::string& sLocation) {
    const std::string& whitespace = " \t";
    printTrace("LE910Radio getModemLocation");
    std::string sCmd("AT$GPSACP");
    std::string sResult = sendCommand(sCmd);
    if (sResult.find("$GPSACP: ") == std::string::npos) {
        printDebug("AT$GPSACP command returned unexpected response: [%s]", sResult.c_str());
        return FAILURE;
    }
    printDebug("modem reply: [%s]", sResult.c_str());
    size_t start = sResult.find(':');
    if (start==std::string::npos){
        start = 0;
    } else {
        start++;
    }
    start = sResult.find_first_not_of(whitespace, start);
    size_t stop = sResult.find('\n', start);
    sLocation = sResult.substr(start, stop - start - 1);

    printDebug("function reply: [%s]", sLocation.c_str());

    return SUCCESS;
}

ICellularRadio::CODE LE910Radio::setUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION newmode) {
    uint8_t iValue;

    switch (newmode) {
        case UE_MODES_OF_OPERATION::PS_MODE1:
            iValue = 3;
            break;
        case UE_MODES_OF_OPERATION::PS_MODE2:
            iValue = 0;
            break;
        case UE_MODES_OF_OPERATION::CS_PS_MODE1:
            iValue = 1;
            break;
        case UE_MODES_OF_OPERATION::CS_PS_MODE2:
            iValue = 2;
            break;
        default:
            printTrace("Set UE Mode Of Operation: invalid argument");
            return CODE::INVALID_ARGS;
    }

    const int dTimeout = 1000; // ms
    const std::string sCommand = "AT+CEMODE=" + MTS::Text::format(iValue);

    return sendBasicCommand(sCommand, dTimeout);
}

ICellularRadio::CODE LE910Radio::getUeModeOfOperation(ICellularRadio::UE_MODES_OF_OPERATION& newmode) {
    const std::string sCommand = "AT+CEMODE?";
    const int dTimeout = 1000; // ms

    std::string sResult = sendCommand(sCommand, ICellularRadio::DEFAULT_BAIL_STRINGS, dTimeout);
    printTrace("Got response from the radio: %s", sResult.c_str());

    size_t end = sResult.rfind(ICellularRadio::RSP_OK);
    if (std::string::npos == end) {
        printWarning("Unable to get UE Mode Of Operation from radio using command [%s]", sCommand.c_str());
        return CODE::FAILURE;
    }

    const std::string sLabel = "+CEMODE: ";
    size_t start = sResult.find(sLabel);
    if (std::string::npos == start) {
        printWarning("Unable to get UE Mode Of Operation from radio using command [%s]", sCommand.c_str());
        return CODE::FAILURE;
    }

    start += sLabel.length();
    const std::string sValue = MTS::Text::trim(sResult.substr(start, end - start));
    uint8_t uiValue;

    if (!MTS::Text::parse(uiValue, sValue)) {
        printWarning("Unable to parse CEMODE from response [%s]", sResult.c_str());
        return CODE::FAILURE;
    }

    CODE rc;
    switch (uiValue) {
        case 0:
            newmode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE2;
            rc = CODE::SUCCESS;
            break;
        case 1:
            newmode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE1;
            rc = CODE::SUCCESS;
            break;
        case 2:
            newmode = ICellularRadio::UE_MODES_OF_OPERATION::CS_PS_MODE2;
            rc = CODE::SUCCESS;
            break;
        case 3:
            newmode = ICellularRadio::UE_MODES_OF_OPERATION::PS_MODE1;
            rc = CODE::SUCCESS;
            break;
        default:
            printWarning("Unable to parse CEMODE from response [%s]", sResult.c_str());
            newmode = ICellularRadio::UE_MODES_OF_OPERATION::UNKNOWN_MODE;
            rc = CODE::FAILURE;
            break;
    }
    return rc;
}