#ifndef SERIAL_H
#define SERIAL_H


speed_t
baud_to_speed_t(int baudrate)
{
    switch (baudrate){

        case 460800:
            return B460800;  //default baudrate for my modem

        case 115200:
            return B115200;
   
        case 19200:
       
            return B19200;
         
           
        default:
            log_event (LOG_WRN, "Velocidad no soportada, default 19200");
            return B19200;
    }    
}


int
set_serial_fd(const char *device, int baudrate,  int databits, char parity, int stopbits)
{
    //Seteo de la interfaz serial
    //Baudrate: 19200, 4800, 2400
    //Parity: 'E'o'e' = Par, 'O' o 'o' = Impar, 'N' o 'n' u otro = Sin Paridad

    struct termios newtio;

    int m_fd, mcs = 0;

    log_event (LOG_DBG, "intentando acceder a dispositivo serial: %s ", device);
   
    if (strlen (device) == 0){
        log_event (LOG_ERR , "Dispositivo de comunicacion erroneo");
        return -1;
    }
   
    if (( m_fd = open ( device, O_RDWR | O_NOCTTY | O_NDELAY ) ) < 0 ){
        log_event (LOG_ERR,"Error abriendo dispositivo serial: %s", __curerr);
        return m_fd;
    }

    memset (&newtio, 0, sizeof (newtio));

    //baudrate
    cfsetospeed (&newtio, baud_to_speed_t(baudrate));
    cfsetispeed (&newtio, baud_to_speed_t(baudrate));

    //databits
    //newtio.c_cflag = (newtio.c_cflag & ~CSIZE) | CS8;
    newtio.c_cflag &= ~CSIZE;
    switch (databits){
        case 5: newtio.c_cflag |= CS5;break;
        case 6: newtio.c_cflag |= CS6;break;
        case 7: newtio.c_cflag |= CS7;break;
        case 8: newtio.c_cflag |= CS8;break;
        default:
            newtio.c_cflag |= CS8;
            log_event(LOG_WRN, "Databits no soportado, default: 8");
            break;
    }

    //stop bits
    switch (stopbits){
        case 1:
            newtio.c_cflag &= ~CSTOPB;
        case 2:
            newtio.c_cflag |= ~CSTOPB;
            break;
        default:
            log_event(LOG_WRN, "Stopbits no soportado, default: 1");
            newtio.c_cflag &= ~CSTOPB;
            break;
    }
   
    //parity
    switch(parity){
        case 'E': //Par
        case 'e':
            newtio.c_cflag |= PARENB;
            newtio.c_cflag &= ~PARODD;
            break;
        case 'O': //Impar
        case 'o':
            newtio.c_cflag |= PARENB;
            newtio.c_cflag &= ~PARODD;
            break;
        case 'N': //Impar
        case 'n':
            newtio.c_cflag &= ~PARENB;
            break;
        default://Sin paridad
            newtio.c_cflag &= ~PARENB;
            log_event(LOG_WRN, "Parity no soportado, default: SIN PARITY");
            break;
    }

    newtio.c_cflag |= CLOCAL | CREAD;
   
    //hardware handshake
    newtio.c_cflag &= ~CRTSCTS;
    newtio.c_cflag &= ~CSTOPB;
    newtio.c_iflag = IGNBRK;

    //software handshake
    newtio.c_iflag |= IXON | IXOFF;
    newtio.c_lflag = 0;
    newtio.c_oflag = 0;


    //control characters
    newtio.c_cc[VTIME] = 1; //tiempo de espera para datos (1=0.1)
    newtio.c_cc[VMIN] = 0; //minimo de caracateres a leer

    //tcflush(m_fd, TCIFLUSH);
    if (tcsetattr (m_fd, TCSANOW, &newtio) != 0)
        log_event (LOG_ERR, "tcsetatty fallo: %s", __curerr);
       
    ioctl (m_fd, TIOCMGET, &mcs);
    mcs |= TIOCM_RTS;
    ioctl (m_fd, TIOCMSET, &mcs);

    if (tcgetattr (m_fd, &newtio)!=0)
        log_event (LOG_ERR, "tcgetattr fallo: %s", __curerr);
   
    if (tcsetattr (m_fd, TCSANOW, &newtio) != 0)
        log_event (LOG_ERR, "tcgetattr fallo: %s", __curerr);

    return m_fd;
}

#endif

-----------------------------

#define ATCMD_SET_AT_MODE      "AT\r"
#define LEN_ATCMD_SET_AT_MODE  3

#define ATCMD_SET_FMT_TXT_MODE "AT+CMGF=1\r"
#define LEN_ATCMD_SET_FMT_TXT_MODE  10

#define ATCMD_SET_DST_CEL_SMS   "AT+CMGS=\"%s\"\r"
#define LEN_ATCMD_SET_DST_CEL_SMS   11

#define ATDEF_OK                "OK"
#define ATDEF_ERROR             "ERROR"


bool
at_send_sms_msg(int fd, char *cel_num, char *msg)
{
    //El msg tiene que ser terminado en \0

    int ret;
    char buff[255], cmd_cel[255] = {0}, msg_tmp[255] = {0};
    bool res;

    snprintf(cmd_cel, 255, ATCMD_SET_DST_CEL_SMS, cel_num);
   
    ret = write_packet(fd, cmd_cel, LEN_ATCMD_SET_DST_CEL_SMS + strlen(cel_num));

    if (ret < 0){
        return -1;
    }

    ret = read_packet(fd, buff);

    res = check_at_command(cmd_cel, LEN_ATCMD_SET_DST_CEL_SMS,  buff, ret);

    if (res == true){
        log_event(LOG_DBG, "set destination cel [OK]");
    }
    else{
        log_event(LOG_DBG, "set destination cel [ERROR]");
        return false;
    }

    bzero(msg_tmp, 255);
    strncat(msg_tmp, msg, 254);
   
    msg_tmp[strlen(msg_tmp)] = 0x1A; //CTRL + Z
   
    ret = write_packet(fd, msg_tmp, strlen(msg_tmp) + 2);
    sleep(10);
    bzero(buff, 255);

    ret = read_packet(fd, buff);

    return true;
}


bool
at_set_fmt_txt_mode(int fd)
{
    int ret;
    char buff[255];
    bool res;
   
    ret = write_packet(fd, ATCMD_SET_FMT_TXT_MODE, LEN_ATCMD_SET_FMT_TXT_MODE);

    if (ret < 0){
        return false;
    }

    ret = read_packet(fd, buff);

    res = check_at_command(ATCMD_SET_FMT_TXT_MODE, LEN_ATCMD_SET_FMT_TXT_MODE, buff, ret);

    if (res == true){
        log_event(LOG_DBG, "set format to TEXT mode [OK]");
    }
    else{
        log_event(LOG_DBG, "set format to TEXT mode [ERROR]");
    }
   
    return res;
}



bool
at_set_at_mode(int fd)
{
    int ret;
    char buff[255];
    bool res;
   
    ret = write_packet(fd, ATCMD_SET_AT_MODE, LEN_ATCMD_SET_AT_MODE);

    if (ret < 0){
        return -1;
    }

    ret = read_packet(fd, buff);

    res = check_at_command(ATCMD_SET_AT_MODE, LEN_ATCMD_SET_AT_MODE, buff, ret);

    if (res == true){
        log_event(LOG_DBG, "set AT mode [OK]");
    }
    else{
        log_event(LOG_DBG, "set AT mode [ERROR]");
    }
   
    return res;
}

bool
check_at_command(char *at_cmd, size_t len_cmd, char *at_answ, size_t len_answ)
{

    if (memcmp(at_cmd, at_answ, len_cmd) == 0)
    {
      if (memcmp(at_answ + len_cmd + 2, ATDEF_OK, 2) == 0) //+2 por el cr cl
          return true;
      else
        {//+2 por el cr cl
        if (memcmp(at_answ + len_cmd + 2, ATDEF_ERROR, 5) == 0)
          return false;
        else
          return true;
      }
     
    }
   
    log_event(LOG_DBG,"unknow answer");

    return false;
   
}

int
read_packet(int fd, char *buff)
{
    struct timeval timeout;
    fd_set readfs;        
    int ret, all_ret = 0;
    char buff_part[255];
    char buff_prnt[255];
    bool once = true;

    FD_ZERO (&readfs);
    FD_SET (fd, &readfs);
 
    while (1){
       
       timeout.tv_usec = 10000; //1 milisegundo
       timeout.tv_sec  = 1;    //0 segundos
       
       if ( select (fd + 1, &readfs, NULL, NULL, &timeout) <= 0 ){
         
         if (once){
           log_event(LOG_DBG, "Error leyendo: Timeout");
           all_ret = -1;
           break;
         }

         all_ret =  once ? -1 : all_ret;
         
         break;
       }

       bzero(buff_part, 255);

       ret = read (fd, buff_part, 255);
       
       memcpy(buff + all_ret, buff_part, ret);

       all_ret += ret;

       if (ret < 0){
           log_event(LOG_ERR, "reading error: %s", __curerr);
           all_ret = -2;
           break;
       }

       once = false;
    }

    bzero(buff_prnt, 255);

    bytes_to_str(buff, all_ret, buff_prnt);

    log_event(LOG_DBG, "<-- %s", buff_prnt);
   
    return ret;
}



int
write_packet(int fd, char *buff, size_t len)
{
    int ret;
    char buff_prnt[255];

    ret = write(fd, buff, len);
 
    if (ret < 0){
        log_event(LOG_ERR, "writing error: %s", __curerr);
    }

    bzero(buff_prnt, 255);

    bytes_to_str(buff, ret, buff_prnt);

    log_event(LOG_DBG, "--> %s", buff_prnt);

    return ret;
}