#include "dn_4g.h"
#include "air780e.h"
#include "masterslave.h"
#include "up_4g.h"
#include "ota_update.h"
#include "taskOpt.h"
#include "public.h"

/*--------------------------------------------------------------------------
 *  升级类  获取设备版本 0x1001
 * --------------------------------------------------------------------------*/
static void dn_4g_update_cmd_0x1001(uint8_t *data, uint8_t len)
{
    uint8_t sendbuff[128], sendlen,i,flag,slaveflag;
    dnUpdateCmd0x1001 *msg = (dnUpdateCmd0x1001*)(data + NET_HEAD_LEN);

    flag = 0;
    slaveflag = 0;

    if(msg->devType == g_devMsg.devType){ // 本设备的设备类型
        if(msg->devSn == g_devMsg.devSn){ // 本设备
            flag = 1;
        }
        else return;
    }
    else { // 从设备的设备类型
        if(g_devMsg.devSn == msg->devSn){ // 固定一个从设备
            slaveflag = 1;
        }
        else if(BROADCAST_SN == msg->devSn){// 广播从设备
            for(i=0;i<g_runNode.slaveNum;i++){
                msg->devType = g_runNode.nodMsg[i].devType;
                msg->devSn   = g_runNode.nodMsg[i].devSn;
                fifo_write(&g_txfifo,data,len);
            }
            slaveflag = 0;
        }
        else return;
    }
    if(1 == flag){
        up_update_cmd_0x2001(sendbuff,&sendlen,msg->taskId);
        add_data_to_4G_txfifo(sendbuff,sendlen,0x04,0x2001);
    }
    if(1 == slaveflag) fifo_write(&g_txfifo,data,len);
}
/*--------------------------------------------------------------------------
 *  升级类 升级下行0x1002
 * -------------------------------------------------------------------------*/
void dn_4g_update_cmd_0x1002(uint8_t *data, uint8_t len)
{
    ota_master_update_task(0x1002,data+NET_HEAD_LEN);
}
/*---------------------------------------------------------------------------
 *  升级类 未安装升级 0x1004
 * --------------------------------------------------------------------------*/
void dn_4g_update_cmd_0x1004(uint8_t *data, uint8_t len)
{
    ota_master_update_task(0x1004,data+NET_HEAD_LEN);
}

/*--------------------------------------------------------------------------
 *  mqtt 服务器切换
 * -------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1003(uint8_t *data, uint8_t len)
{
    dnSysCmd0x1003 *msg = (dnSysCmd0x1003*)(data + NET_HEAD_LEN);

    //if(0== check_dev_type_sn(msg->devTypeM,msg->devSnM)) return;
    if(DEV_TYPE != msg->devTypeM) return;
    if(msg->devSnM != g_devMsg.devSn) return;
    close_mqtt();
    printf("收到mqtt切换指令 \r\n");
    init_4g_power_up();
    memset(&(g_mqttCHmsg.mqttMsg),0,sizeof(g_mqttCHmsg));

    memcpy(g_mqttCHmsg.mqttMsg.ip,msg->str,msg->iplen);
    len = msg->iplen;
    memcpy(g_mqttCHmsg.mqttMsg.port,msg->str+len,msg->portlen);
    len += msg->portlen;
    memcpy(g_mqttCHmsg.mqttMsg.admin,msg->str+len,msg->userlen);
    len += msg->userlen;
    memcpy(g_mqttCHmsg.mqttMsg.password,msg->str+len,msg->pwdlen);

    g_mqttCHmsg.mqttIdlen = msg->iplen;
    g_mqttCHmsg.mqttPortlen = msg->portlen;
    g_mqttCHmsg.mqttUserlen = msg->userlen;
    g_mqttCHmsg.mqttPwdlen = msg->pwdlen;

    g_mqttCHmsg.bChangeMqtt = 1;
    g_4gMsg.bconnect= 0;
    g_devMsg.baskIdentity = 0x00;
    g_mqttCHmsg.connectNum = 0;
    g_4gMsg.cregStatus = 0;
    timeout_stop(&g_4gMsg.timer);

}
/*----------------------------------------------------------------------------
 *  设备重启 0x1021
 * ---------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1021(uint8_t *data,uint8_t len)
{
    dnSysCmd0x1021 *msg = (dnSysCmd0x1021*)(data+NET_HEAD_LEN);

    if(DEV_TYPE == msg->devTypeS){// 本设备的设备类型
        if(msg->devSnS == g_devMsg.devSn){// 本设备
            if(2 == msg->object)NVIC_SystemReset();
        }
    }
    else {// 从设备, 直接透传
        fifo_write(&g_txfifo,data,len);
    }

}
/*--------------------------------------------------------------------------------
 *  时间同步 0x1015
 * -------------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1015(uint8_t *data,uint8_t len)
{
    dnSysCmd0x1015 *msg = (dnSysCmd0x1015*)(data+NET_HEAD_LEN);

    set_time(msg->timer);
    fifo_write(&g_txfifo,data,len);
    g_taskRunDa.timetamp = msg->timer;
    printf("收到时间同步, %d\r\n",g_taskRunDa.timetamp);
}
/*------------------------------------------------------------------------------------
 *  身份应答  0x1041
 * -----------------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1041(uint8_t *data, uint8_t len)
{
//    dnSysCmd0x1041 *msg = (dnSysCmd0x1041*)(data+NET_HEAD_LEN);

//    if(0 == check_dev_type_sn(msg->devTypeM,msg->devSnM)) return;
//    g_iDentity = (Identity)msg->relation;
//    printf("收到服务的配置身份 = %d\r\n", g_iDentity);
//    if(IDENTITY_MASTER == g_iDentity ){
//        epprom_read_config_table(); // 接收到自己是主的指令，则读取路表
//    }
    g_iDentity = IDENTITY_MASTER;
    return;
}
/*------------------------------------------------------------------------------------
 *  路由表初下发 0x1024
 * -----------------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1024(uint8_t *data, uint8_t len)
{
    dnSysCmd0x1024 *msg = (dnSysCmd0x1024*)(data+NET_HEAD_LEN);

    if((msg->devTypeM==g_devMsg.devType) &&(msg->devSnM==g_devMsg.devSn)){
        epprom_init_config_table();
        epprom_write_config_table(msg->buff,len-6);
        epprom_read_config_table();
    }
}
/*------------------------------------------------------------------------------------
 *  路由表问询 0x1025
 * -----------------------------------------------------------------------------------*/
static void dn_4g_system_cmd_0x1025(uint8_t *data, uint8_t len)
{
    uint8_t buff[180] = {0},len1;

    dnSysCmd0x1025 *msg = (dnSysCmd0x1025*)(data+NET_HEAD_LEN);

    //if(0 == check_dev_type_sn(msg->targetType,msg->targetSn)) return;
    if((msg->targetType != DEV_TYPE) || (msg->targetSn != g_devMsg.devSn)) return;
    up_system_cmd_0x2025(buff,&len1,msg->targetType,msg->targetSn);
    epprom_read((uint32_t)CONFIGTABLE_ADDR,&buff[len1],g_runNode.slaveNum*8+1);
    add_data_to_4G_txfifo(buff,g_runNode.slaveNum*8+1+len1,0x01,0x2025);

}
static void dn_4g_system_cmd_0x1026(uint8_t *data, uint8_t len)
{
//    DnSysCmd0x1026 *msg = (DnSysCmd0x1026*)(data + NET_HEAD_LEN);
//    uint8_t flag = 0; // 3:主从都有， 1：主 2：从
//    if((msg->da1026.appointDevModel == g_devMsg.devType)) {
//        if((0xFFFFFFFF == msg->devSnS) ){ //
//            flag = 0x03;
//        }
//        else if(msg->devSnS == g_devMsg.devSn) {
//            flag = 0x01;
//        }
//        else if(msg->devSnS != g_devMsg.devSn) {
//                flag = 0x02;
//        }
//        if((0x03 == flag) || (0x02==flag)){ // 直接透传给从设备
//            fifo_write(&g_txfifo,data,len);
//        }
//    }
//    else { // 不是给主的，或许是给从的
//        fifo_write(&g_txfifo,data,len);
//    }
    fifo_write(&g_txfifo,data,len);
}
void anlaysis_0x1027(uint8_t *data,uint8_t framNo,uint16_t time)
{
    static uint8_t groupId;
    uint8_t flag = 0,i=0;
    sysCmd1027 *msg = (sysCmd1027*)data;

    if(0xFF == framNo){ // 单帧
        groupId = 0;
        memcpy((uint8_t*)&g_table1027,data,sizeof(sysCmd1027));
        g_table1027.groupNum = msg->groupNum;
        flag = 1;
    }
    else if((framNo&0x80) == 0x80){ // 多帧的第一帧
        groupId = 0;
        memcpy((uint8_t*)&g_temtable1027,data,sizeof(sysCmd1027));
        groupId = msg->groupNum;

    }
    else if((framNo%0x0F) != 0x01) { // 多帧的中间帧
        memcpy(g_temtable1027.table[groupId],msg->table,sizeof(sysCmd1027)-11);
        groupId += msg->groupNum;
    }
    else if((framNo&0x01) == 0x01) { // 多帧的最后一帧
        memcpy(g_temtable1027.table[groupId],msg->table,sizeof(sysCmd1027)-11);
        groupId += msg->groupNum;
        g_temtable1027.groupNum = groupId;
        flag = 1;
        memcpy(&g_table1027,&g_temtable1027,sizeof(sysCmd1027));// 将临时表中的数据放入到用到的表中
    }

    if( (1 == flag) ){
        if((0==time)){
            epprom_write_pin_config((uint8_t*)&g_table1027,(uint16_t)sizeof(sysCmd1027)); // 写入EEPROm中
            g_taskRunDa.bcfgfiletime = 0;
        }
        else {
            timeout_setValue(&g_taskRunDa.cfigFileTime,time*1000);
            timeout_start(&g_taskRunDa.cfigFileTime);
            g_taskRunDa.bcfgfiletime = 1;
        }
        for(i=0;i<g_table1027.groupNum;i++){
            if(i%10 == 0) printf("\r\n");
            printf("{%d,%2d},",g_table1027.table[i][0],g_table1027.table[i][1]);

        }
    }
}

static void dn_4g_system_cmd_0x1027(uint8_t *data, uint8_t len)
{
//     DnSysCmd0x1027 *msg = (DnSysCmd0x1027*)(data + NET_HEAD_LEN);
//     uint8_t flag = 0; // 1: 主 2： 从 3： 主从
//     if(msg->da1027.appointDevModel == g_devMsg.devType){
//        if((0xFFFFFFFF == msg->devSnS)){
//            flag = 3;
//        }
//        else if(msg->devSnS == g_devMsg.devSn){
//            flag = 1;
//        }
//        else {
//            flag = 2;
//        }
//        if((3==flag) || (2==flag)){
//            fifo_write(&g_txfifo,data,len);
//        }
//    }
//     else { // 不是给主的，或许是给从设备的
//        fifo_write(&g_txfifo,data,len);
//    }
     fifo_write(&g_txfifo,data,len);
}
static void dn_4g_system_cmd_0x1028(uint8_t *data, uint8_t len)
{
    DnSysCmd0x1028 *msg = (DnSysCmd0x1028*)(data+NET_HEAD_LEN);
    uint8_t flag = 0; // 1: 主 2： 从 3： 主从


    if(msg->devTypeM != DEV_TYPE) return;
    if(msg->devSnM != g_devMsg.devSn) return;

    if(0xFFFFFFFF == msg->devSnS) flag = 3;
    else flag = 2;

    timeout_setValue(&g_up7segData.upTime,msg->time*1000);
    g_up7segData.bOpen = 1;
    timeout_start(&g_up7segData.upTime);

    timeout_setValue(&g_logMsg.singTime,TIME_SING_N);
    timeout_start(&g_logMsg.singTime);
    timeout_stop(&g_logMsg.tsingTime);
    g_logMsg.singOpen = 0;

    if(3 == flag) g_up7segData.bAppointDev = 0; // 未指定设备主从都需要报

    if((2==flag) || (3==flag)){
        fifo_write(&g_txfifo,data,len);
    }
    if(2 == flag){
        g_up7segData.bAppointDev = 2; // 指定设备为从设备
        memcpy(g_up7segData.devMsg,(uint8_t*)msg,12);
    }
}
static void dn_4g_system_cmd_0x1029(uint8_t *data, uint8_t len)
{
    DnSysCmd0x1029 *msg = (DnSysCmd0x1029*)(data + NET_HEAD_LEN);

    if(msg->devTypeM != DEV_TYPE) return;
    if(msg->devSnM != g_devMsg.devSn) return;

    g_up7segData.bOpen = 0;
    g_up7segData.bAppointDev = 0;
    timeout_stop(&g_up7segData.upTime);

    fifo_write(&g_txfifo,data,len);

}

void dn_4g_system_cmd(uint16_t cmd, uint8_t *data, uint8_t len)
{
    switch(cmd){
    case 0x1003: // mqtt 配置
        dn_4g_system_cmd_0x1003(data,len);
        break;
    case 0x1021: // 系统重启
        dn_4g_system_cmd_0x1021(data,len);
        break;
    case 0x1015: // 时间同步
        dn_4g_system_cmd_0x1015(data,len);
        break;
    case 0x1041: // 身份应答
        dn_4g_system_cmd_0x1041(data, len);
        break;
    case 0x1024: // 路由表下 行
        dn_4g_system_cmd_0x1024(data, len);
        break;
    case 0x1025: // 路由表问询
        dn_4g_system_cmd_0x1025(data, len);
        break;
    case 0x1026: // com 端配置文件下发
        dn_4g_system_cmd_0x1026(data,len);
        break;
    case 0x1027: // 探针板管脚配置文件下发
        dn_4g_system_cmd_0x1027(data,len);
        break;
    case 0x1028: // 开启8段码测试
        dn_4g_system_cmd_0x1028(data,len);
        break;
    case 0x1029: // 关闭8段码测试
        dn_4g_system_cmd_0x1029(data,len);
        break;
    }
}

/*--------------------------------------------------------------------------
 *  显示屏的数据读取
 * -------------------------------------------------------------------------*/
static void dn_4g_data_cmd_0x1061(uint8_t *data, uint8_t len)
{
    fifo_write(&g_txfifo,data,len);
}

/*--------------------------------------------------------------------------
 *
 * -------------------------------------------------------------------------*/
void dn_4g_data_cmd(uint16_t cmd, uint8_t *data, uint8_t len)
{
    switch(cmd){
    case 0x1061: // 显示屏数据
        dn_4g_data_cmd_0x1061(data, len);
        break;
    }
}

void dn_4g_update_cmd(uint16_t cmd, uint8_t *data, uint8_t len)
{
    switch(cmd) {
    case 0x1001: // 获取设备版本
        dn_4g_update_cmd_0x1001(data,len);
        break;
    case 0x1002: // 升级下发指令
        dn_4g_update_cmd_0x1002(data,len);
        break;
    case 0x1004: // 未安装升级
        printf("收到未安装升级指令1004\r\n");
        dn_4g_update_cmd_0x1004(data,len);
        break;
    }
}

/*------------------------------------异常类0x10的处理---------------------------*/

/*--------------------------------------------------------------------------
 *  日志0x1062
 * -------------------------------------------------------------------------*/
static void dn_4g_log_cmd_0x1062(uint8_t *data, uint8_t len)
{
    DnLogCmd0x1062 *msg = (DnLogCmd0x1062*)(data+NET_HEAD_LEN);

    //fifo_write(&g_txfifo,data,len);
    printf("收到10----1062指令 delay = %d type=%d\r\n",msg->time,msg->logType);

    if(msg->time == 0x00){
        g_logMsg.blogOpen = 0x00;
        return;
    }
    if((msg->logType == 0x02)) {

        g_logMsg.blogOpen = 1;
        timeout_setValue(&g_logMsg.logtime,msg->time*1000);
    }
}

/*--------------------------------------------------------------------------
 *  日志0x1063
 * -------------------------------------------------------------------------*/
static void dn_4g_log_cmd_0x1063(uint8_t *data, uint8_t len)
{
    DnLogCmd0x1063 *msg = (DnLogCmd0x1063*)(data+NET_HEAD_LEN);

    //fifo_write(&g_txfifo,data,len);
    printf("收到10----1063指令 delay = %d interval = %d type=%d\r\n",msg->time,msg->interval, msg->logType);

    if(msg->logType == 0x03){
        if(msg->time == 0x00){
            timeout_setValue(&g_logMsg.singTime,TIME_SING_N);
            timeout_start(&g_logMsg.singTime);
            g_logMsg.singOpen = 0;
        }
        else {
            g_up7segData.bOpen = 0;
            g_up7segData.bAppointDev = 0;
            timeout_stop(&g_up7segData.upTime);

            g_logMsg.devSn = msg->devSnS;
            g_logMsg.devType = msg->devTypeS;

            if(msg->interval <2) msg->interval = 2;
            if(msg->time <5) msg->time = 5;
            if(msg->time > 20*60*1000) msg->time = 20*60*1000;
            if(msg->interval > msg->time) msg->interval = msg->time -2;
            timeout_setValue(&g_logMsg.singTime,msg->interval*1000);
            timeout_setValue(&g_logMsg.tsingTime,msg->time*1000);
            timeout_start(&g_logMsg.tsingTime);
            timeout_start(&g_logMsg.singTime);
            timeout_stop(&g_logMsg.singTime);
            g_logMsg.singOpen = 1;
        }

    }

}
void dn_4g_log_cmd(uint16_t cmd, uint8_t *data, uint8_t len)
{
    switch(cmd) {
    case 0x1062: // 日志开启
        dn_4g_log_cmd_0x1062(data, len);
        break;
    case 0x1063:
        dn_4g_log_cmd_0x1063(data, len);
    default: break;

    }
}