/*********************************************************************************
 *      Copyright:  (C) guowenxue <guowenxue@gmail.com>
 *                  All rights reserved.
 *
 *       Filename:  cp_atcmd.c 
 *    Description:  This is file is used to send AT command to GPRS module. 
 *                 
 *        Version:  1.0.0(02/02/2012~)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "02/02/2012 10:28:44 AM"
 *                 
 ********************************************************************************/

#include "cp_atcmd.h"
#include "cp_string.h"
#include "cp_logger.h"
#include "cp_time.h"

#ifndef ATCMD_REPLY_LEN 
#define ATCMD_REPLY_LEN          512
#endif

/*
 *  Description: Send the AT command which modem will only reply "OK" or "ERROR",
 *               such as AT,ATE0,AT+CNMP=2 etc.
 *
 * Return Value:  0: OK     -X: ERROR
 */
int send_atcmd_check_ok(comport_t *comport, char *atcmd, unsigned long timeout)
{
    int  retval;
    retval = send_atcmd(comport, atcmd, "OK\r\n", "ERROR\r\n", timeout, NULL, 0);

    return 0==retval ? 0 : -2;
}

/*
 *  Description: Send the AT command which will reply the value directly in a  
 *               single line, such as AT+CGMM, AT+CGSN
 *
 * Output Value: Buf: The AT command query value
 * Return Value:  0: OK     -X: ERROR
 *
 */
int send_atcmd_check_value(comport_t *comport, char *atcmd, unsigned long timeout, char *buf, int buf_len)
{
    int         i = 0;
    int         retval=0; 
    char        tmp[ATCMD_REPLY_LEN];
    char        *start;

    if(NULL==buf)
    {
        log_err("Function call arguments error!\n");
        return -1;
    }

    memset(tmp, 0, sizeof(tmp));
    retval = send_atcmd(comport, atcmd, "OK\r\n", "ERROR\r\n", timeout, tmp, sizeof(tmp));
    if( 0 != retval)
    {
        return -2;  /* AT command can not get reply  */
    }

    /* Parser the receive string to get the expect value*/
    if(NULL != (start=strchr(tmp, '\n')) )  
    {
        start ++;  /* Skip '\n' character */
        while(*start!='\r' && i<buf_len-1)
        {
            buf[i++] = *start; 
            start ++;
        }
    }
    buf[i] = '\0'; /* End of the string */

    return ('\0'==buf[0] ? -3 : 0);
}

/*
 *  Description: Send the AT command which will reply the value with a prefix "+CMD: "  
 *               single line, such as AT+CGMR  AT+CPIN? AT+CNMP? AT+CSQ
 *
 * Output Value: Buf: The AT command query value by remove "+XXX:" prefix
 * Return Value:  0: OK     -X: ERROR
 *
 */
int send_atcmd_check_request(comport_t *comport, char *atcmd, unsigned long timeout, char *buf, int buf_len)
{
    int         retval;
    int         i = 0;
    char        tmp[ATCMD_REPLY_LEN];
    char        *ptr = NULL;

    if(NULL==buf)
    {
        log_err("%s() call arguments error!\n", __FUNCTION__);
        return -1;
    }

    memset(tmp, 0, sizeof(tmp));
    retval = send_atcmd(comport, atcmd, "OK\r\n", "ERROR\r\n", timeout, tmp, sizeof(tmp));
    if( 0 != retval)
    {
        return -2;
    }

    /* Parser the receive string to get the expect value*/
    if(NULL != (ptr=strchr (tmp, ':')) )   
    {
        ptr += 2; /* Skip the ':' and SPACE character */ 
        while(*ptr!='\r' && i<buf_len-1)
        {
            buf[i++] = *ptr; 
            ptr ++;
        } 
    }
    buf[i] = '\0'; /* End of the string */

    return ('\0'==buf[0] ? -3 : 0);
}


/*
 *  Description: Send ATE0 command to the GSM module to check GSM module ready or not
 * Return Value: 0: Success  !0:Failure
 */
int atcmd_check_at_ready(comport_t *comport)
{
    int    retval;
    retval=send_atcmd_check_ok(comport, "ATE0\r", 500);
    if(retval)
    {
        log_err("ATE0 check AT command ready             [FAILED]\n"); 
    }
    else
    log_nrml("ATE0 check AT command ready           [OK]\n"); 

    return retval;
}

/*
 *  Description: Send AT+CPIN? command to the GSM module to check SIM card exist or not
 * Return Value: 0: Success  !0:Failure
 */
int atcmd_check_sim_valid(comport_t *comport)
{
    int         retval = 0; 
    char        recv_buf[ATCMD_REPLY_LEN];

    retval = send_atcmd_check_request(comport, "AT+CPIN?\r", 800, recv_buf, sizeof(recv_buf));
    if(0x00 != retval)
    {
        retval = 1;
        log_warn("AT+CPIN? Check SIM Validation:          [FAILED]\n");
        return retval;
    }

    if(strstr(recv_buf, "READY"))
    {
        log_nrml("AT+CPIN? Check SIM Validataion:       [OK]\n");
        return 0;
    }
    else
        return -1;
}

/*  Send AT+CSQ command to check GPRS signal*/
int atcmd_check_gprs_signal(comport_t *comport)
{
    char        recv_buf[ATCMD_REPLY_LEN]; 
    int         retval;
    int         signal = -1;
    
    memset(recv_buf, 0, sizeof(recv_buf));
    retval = send_atcmd_check_request(comport, "AT+CSQ\r", 3000, recv_buf, sizeof(recv_buf));
    if( 0 !=  retval)
    {
        log_err("AT+CSQ Check Signal Strength:          [FAILED]\n");
        return retval;
    } 

    split_string_to_value(recv_buf, "%d,%d", &signal, NULL);

    log_nrml("AT+CSQ Check Signal Strength:         [%d]\n", signal);

    return signal;
}

/* Send AT+CREG? command to check SIM card register status */
int atcmd_check_gprs_register(comport_t *comport)
{
    int         retval, stat = -1;
    char        recv_buf[ATCMD_REPLY_LEN]; 

    memset(recv_buf, 0, sizeof(recv_buf));
    retval = send_atcmd_check_request(comport, "AT+CREG?\r", 3000, recv_buf, sizeof(recv_buf));
    if( 0 !=  retval)
    {
        log_err("AT+CREG? Check SIM card Register:      [FAILED]\n");
        return stat;
    } 
    
    split_string_to_value(recv_buf, "%d,%d", NULL, &stat);
    log_nrml("AT+CREG? Check SIM Card Register:     [%d]\n", stat);

    return stat;
}


int atcmd_check_gprs_carrier(comport_t *comport, char *carrier)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
 
    if(carrier == NULL)
    {
        return -1;
    }

    retval = send_atcmd_check_request(comport, "AT+COPS?\r", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+COPS? Check SIM Card Carrier:        [FAILED]\n");
        return retval;
    }

    split_string_to_value(recv_buf, "%d,%d,%s,%d", NULL, NULL, carrier, NULL);
    del_char_from_string(carrier, '\"');

    log_nrml("AT+COPS? Check SIM Card Carrier:      [%s]\n", carrier);

    return 0;
}

int atcmd_check_gprs_mcc_mnc(comport_t *comport, char *mcc_mnc)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
    int               status;
    char              mcc[5];
    char              mnc[5];
    char              *ptr = NULL;

    retval=send_atcmd_check_ok(comport, "AT+QENG=1\r", 1000);
    if(retval) 
    {
        log_err("Send AT command AT+QENG=1 failure\n");
        return retval;
    }

    retval = send_atcmd(comport, "AT+QENG?\r", "OK\r\n", "ERROR\r\n", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_err("AT+QENG? Check GPRS MCC and MNC failure\n");
        return retval;
    }

    /* AT+QENG? respond value:
     * +QENG: 1,0
     * +QENG: 0,460,00,7108,80c4,554,41,-95,18,50,0,10,x,x,x,x,x,x,x  
     */
    if(NULL != (ptr=strrchr (recv_buf, ':')) )   
    {
        split_string_to_value(ptr, "%d,%s,%s,%s", &status, mcc, mnc, NULL);
        if(!status)
        {
            sprintf(mcc_mnc, "%s-%s", mcc, mnc);
            log_nrml("AT+QGSMLOC=1 Check GPRS Location MCC-MNC: %s\n", mcc_mnc);
            return 0;
        }
    }

    printf("ptr: %s\n", ptr);

    return -1;
}


int atcmd_check_gprs_location(comport_t *comport, gprs_location_t *loc)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
    int               status;
    
    retval=send_atcmd_check_ok(comport, "AT+QIFGCNT=0\r", 1000);
    if(retval) 
    {
        log_warn("Send AT command AT+QIFGCNT=0 failure\n");
        return retval;
    }

    retval = send_atcmd_check_request(comport, "AT+QGSMLOC=1\r", 10000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+QGSMLOC=1 Check GPRS Location:         [FAILED]\n");
        return retval;
    }

    /* +QGSMLOC: 0,114.389210,30.500380,2013/01/16,14:03:12, it's GMT time  */
    split_string_to_value(recv_buf, "%d,%s,%s,%s,%s", &status, loc->longitude, loc->latitude, loc->date, loc->time);

    if(status) /* Get LOC failure */
    {
        memset(loc->longitude, 0, sizeof(loc->longitude));
        memset(loc->latitude, 0, sizeof(loc->latitude));
        memset(loc->date, 0, sizeof(loc->date));
        memset(loc->time, 0, sizeof(loc->time));
        log_warn("AT+QGSMLOC=1 Check GPRS Location failure: %s\n", recv_buf);
        return -1;
    }

    log_nrml("GPRS location result=%d latitude,longitude: [%s,%s]\n", status, loc->latitude, loc->longitude);
    log_nrml("GPRS Date and time: %s,%s\n", loc->date, loc->time);

    return retval;
}


int atcmd_set_network_mode(comport_t *comport, int mode)
{
    int              retval;
    char             atcmd[64]={0}; 

    sprintf (atcmd, "AT+CNMP=%d\r", mode); 
    if(0 != (retval=send_atcmd_check_ok(comport, atcmd, 3000)) )
    {
        log_warn("AT+CNMP Set Network Mode as %d:      [FAILED]\n", mode);
        return retval;
    } 
    log_nrml("AT+CNMP=%d Set Network Mode:          [OK]\n", mode);

    /* AT+CNAOP=?: 0->Automatic, 1->GSM,WCDMA, 2->WCDMA,GSM */
    strncpy (atcmd, "AT+CNAOP=2\r", sizeof(atcmd)); 
    if(0 != (retval=send_atcmd_check_ok(comport, atcmd, 3000)) )
    {
        log_warn("AT+CNAOP=2 Set Acquisitions order preference to WCDMA,GSM     [FAILED]\n");
        return retval;
    } 
    log_nrml("AT+CNAOP=2 Set Network Preference     [OK]\n");

    return 0;
}

int atcmd_check_gprs_name(comport_t *comport, char *name)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
 
    if(name == NULL)
    {
        return -1;
    }

    retval = send_atcmd_check_value(comport, "AT+CGMM\r", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+CGMM Check GPRS Module Name:         [FAILED]\n");
        return retval;
    }

    strcpy(name, recv_buf);

    log_nrml("AT+CGMM Check GPRS Module Name:       [%s]\n", name);

    return 0;
}


int atcmd_check_gprs_version(comport_t *comport, char *version)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
 
    if(version == NULL)
    {
        return -1;
    }

    retval = send_atcmd_check_request(comport, "AT+CGMR\r", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+CGMR Check GPRS Module Version:      [FAILED]\n");
        return retval;
    }

    strcpy(version, recv_buf);
    log_nrml("AT+CGMR Check GPRS Module Version:    [%s]\n", version);

    return 0;
}

int atcmd_check_gprs_iemi(comport_t *comport, char *iemi)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
 
    if(iemi == NULL)
    {
        return -1;
    }

    retval = send_atcmd_check_value(comport, "AT+CGSN\r", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+CGSN Check GPRS Module IEMI:      [FAILED]\n");
        return retval;
    }

    strcpy(iemi, recv_buf);
    log_nrml("AT+CGSN Check GPRS Module IEMI:       [%s]\n", iemi);

    return 0;
}


int atcmd_check_gprs_network(comport_t *comport, int *network)
{
    int               retval;
    char              recv_buf[ATCMD_REPLY_LEN];
 
    if(network == NULL)
    {
        return -1;
    }

    retval = send_atcmd_check_request(comport, "AT+CNSMOD?\r", 5000, recv_buf, sizeof(recv_buf));
    if(retval) 
    {
        log_warn("AT+CNSMOD Check Network Mode:        [FAILED]\n");
        return retval;
    }

    split_string_to_value(recv_buf, "%d,%d", NULL, network);

    log_nrml("AT+CNSMOD? Check Network Mode:        [%d]\n", *network);
    return 0;
}


int atcmd_set_apn(comport_t *comport, char *apn)
{
    char             atcmd[64]={0};
    int              retval; 
    
    sprintf (atcmd, "AT+CGDCONT=1,\"IP\",\"%s\"\r", apn);
    if(0 != (retval=send_atcmd_check_ok(comport, atcmd, 2000)) )
    {
        log_err("AT+CGDCONT Set APN as \"%s\"         [FAILED]\n", apn); 
        return retval;
    }

    log_nrml("AT+CGDCONT Set APN as \"%s\"          [OK]\n");
    return retval;
}


unsigned char at_match (char *p_pcStr, char *p_pcMatch)
{
    char                    acBuf [256],
                            *pcStart = NULL,
                            *pcTab   = NULL;

    pcStart = p_pcMatch; 
    
    while (0 != pcStart)
    {
        memset (acBuf, 0x00, sizeof (acBuf)); 

        pcTab = strchr (pcStart, 9);    // Find for TAB 
        if (0 != pcTab)
        {
            if (pcTab != pcStart)
            {
                strncpy (acBuf, pcStart, pcTab - pcStart);
            } 
            pcStart = (0 != *(++pcTab)) ? pcTab : 0;
        }
        else
        {
            strcpy (acBuf, pcStart); 
            pcStart = NULL;
        } 
        if (0 != acBuf [0] && 0 != strstr (p_pcStr, acBuf))
        {
            return 0x00;
        }
    } 
    return 0x01;
}

 
/*=========================================================================================================
 * Parameter Description:  
 *     comport_t    *comport:  The GPRS module data port(/dev/ttyS2);  
 *     char          *atCmd:  The AT command which will be sent to GPRS module
 *     char         *expect:  The EXPECT reply string by GPRS module for the AT command, such as "OK"
 *     char          *error:  The ERROR  reply string by GPRS module for the AT command, such as "ERROR"
 *   unsigned long  timeout:  Read from data port timeout value
 *     char           reply:  The AT command reply output buffer
 *     int        reply_len:  The AT command reply output buffer length
 *
 * Return Value:
 *     int           retval:   0->command send OK and "expect" string mached. !0->failure
 *     char        *content:   The AT command reply string by modem.
 *
 *=========================================================================================================*/

int send_atcmd(comport_t *comport, char *atCmd, char *expect, char *error,
              unsigned long timeout, char *reply, int reply_len)
{
    int                  retval = -1; 
    unsigned long        delay = 200;
    unsigned long        gap = 300;
    unsigned long        ulStartTime; 
    
    int                  iCmdLen = 0,
                         iRecvLen = 0,
                         iRecvSize = 0,
                         iSize = 0;

    
    char                 acRecv[1024];
    char                 *pcRecvPtr = NULL; 
    
    if(comport->is_connted != 0x01) /* Comport not opened */
    {
        log_dbg("Comport not opened.\n");
        return  -1;
    }

#if 0
    /*=========================================
     *=  Pause a while before send AT command =
     *=========================================*/
    if(0 != delay)
    {
        ulStartTime = time_now();
        while (time_elapsed(ulStartTime) < delay)
        {
            micro_second_sleep(1);
        }
    }
#endif

    /*====================
     *=  Throw Rubbish   =
     *====================*/
    ulStartTime = time_now(); 
    memset(&acRecv, 0, sizeof(acRecv));

    while (time_elapsed(ulStartTime) < delay)
    {
        iSize = comport_recv(comport, acRecv, 1, 50);
        if(iSize <= 0)
        {
            break;
        } 
        micro_second_sleep(1);
    }

    /*====================
     *=  Send AT command =
     *====================*/

    iCmdLen = strlen(atCmd);
    retval = comport_send (comport, atCmd, iCmdLen);
    if (0 != retval)
    {
        retval = 0x02;
        goto  CleanUp;
    }

    /*===================================================
     *=  Pause a while before read command response. 
     *===================================================*/
    if(0 != gap)
    {
        ulStartTime = time_now();
        while (time_elapsed(ulStartTime) < gap)
        {
            micro_second_sleep(1);
        }
    }
    
    memset (acRecv, 0, sizeof (acRecv));
    pcRecvPtr = acRecv;
    iRecvLen = 0;
    iRecvSize = sizeof (acRecv);

    retval = -1;
    ulStartTime = time_now();

    while (time_elapsed(ulStartTime) < timeout)
    {
        if ( iRecvLen < (iRecvSize-1) )
        {
            iSize = comport_recv (comport, pcRecvPtr, 1, 50); 
            if (iSize >0)
            {
                iRecvLen += iSize;
                pcRecvPtr += iSize;
                acRecv [iRecvSize-1] = 0;

                /*========================================
                 * Match the received with expect String =
                 *========================================*/
                if(NULL != expect)
                {
                    if (0x00 == at_match(acRecv, expect))
                    {
                        retval = 0;
                        goto CleanUp;
                    }
                } 
                
                /*======================================== 
                 * Match the received with error String  = 
                 *========================================*/
                if(NULL != error)
                {
                    if (0x00 == at_match(acRecv, error))
                    { 
                        retval = -3;
                        goto CleanUp;
                    }
                } 
            } /*End of (iSize > 0)  */ 
        } /* End of (iRecvLen < (iRecvSize-1))  */ 
        
        micro_second_sleep(1);
    } /* End of time_elapsed(ulStartTime) < timeout */


    if(NULL==expect)
        retval = 0x00;
    else
        retval = -4; 

CleanUp:
    //printf("acRecv:\n %s\n", acRecv);
    if( NULL != reply)
    {
        strncpy(reply, acRecv, reply_len);
    }

#if 1  /* Log the command result to log system  */
    {
        char   log[512] = {0};
        snprintf(log, 512, "Send AT command: \"%s\" get reply \"%s\"", atCmd, acRecv);
        int i = 0;
        for (i=0; i<512; i++)
        {
            if('\r'==log[i] || '\n'==log[i] || '\t'==log[i]) 
            {
                log[i]=' '; 
            }
            else if (0 == log[i]) 
            {
                break;
            } 
        }
        log_info("%s\n", log);
    }
#endif 
    
    return retval;
}