#include "cmd_coder.h"
#include "QDebug"







// task_id,errcode,par_count,ret_count
static const task_def g_ew_task_table[]={
{"电源准备",0,1,10,0},
{"延时等待",1,1,2,1},
{"桥丝电阻测试",2,4,1,1},
{"上电充能",3,2,3,2},
{"设置总线电压",4,1,1,1},
{"获取总线电流",5,1,0,2},
{"使能MTP",6,5,1,0},
{"扫描UID",7,5,3,8},
{"写配置参数",8,5,7,0},
{"检测配置",9,5,7,0},
{"验证配置",10,5,4,0},
{"模拟注码",11,5,0,0},
{"验证模拟注码",12,5,0,0},
{"芯片自检",13,5,2,1},
{"状态检测",14,5,2,2},
{"充电",15,5,2,0},
{"放电",16,5,0,0},
{"写延时",17,5,1,0},
{"读延时",18,5,0,1},
{"时钟校准",19,5,2,1},
{"设置通信地址",20,5,3,1},
{"状态巡检",21,5,3,1},
{"起爆使能",22,5,0,0},
{"起爆检测",23,5,3,1},
{"缓存数据写入MTP",24,5,3,0},
{"验证缓存数据",25,5,3,0},
{"关总线",26,1,0,0},
{"升级",27,5,4,1},
{"充能统计",28,2,6,4},
{"计算异常",29,0,10,0},
{"重新执行任务",30,0,1,0},
{"写入三码数据",31,5,0,0},
{"验证三码数据",32,5,0,0},
{"配置三码数据到小板",33,1,10,0},
{"任务插槽",34,0,1,0},
{"读MTP",35,5,2,8},
{"写MTP",36,5,10,0},
{"设置电阻校准值",37,1,1,0},
{nullptr,0,0,0,0},
};





// task_id,errcode,par_count,ret_count
static const task_def g_jq_task_table[]={
{"电源准备",0,1,10,0},
{"上电充能",1,2,3,2},
{"设置总线电压",2,1,1,1},
{"获取总线电流",3,1,0,2},
{"扫描UID",4,5,2,8},
{"密码验证",5,5,1,0},
{"读取芯片代码",6,5,0,1},
{"OTP检测",7,5,3,0},
{"工厂测试检测",8,5,0,0},
{"读取状态",9,5,1,0},
{"写工厂信息",10,5,2,0},
{"充能统计",11,5,5,4},
{"充电电压检测",12,5,2,1},
{"延时等待",13,1,2,1},
{"写延时",14,5,1,0},
{"读延时",15,5,0,1},
{"时钟校准",16,5,2,1},
{"放电",17,5,2,0},
{"复位",18,5,0,0},
{"起爆使能",19,5,0,0},
{"起爆充能",20,5,3,3},
{"使能通讯末电流采集",21,1,0,0},
{"获取通讯末电流",22,1,0,1},
{"写OTP",23,5,6,0},// opt_addr,len,[data]
{"读OTP",24,5,2,10},// 这个任务根据参数1得到实际读取长度
{"清除起爆计数",25,5,0,0},
{"关总线",26,1,0,0},
{"将缓存区数据写入OTP",27,5,3,0},
{"写入三码数据",28,5,0,0},
{"验证三码数据",29,5,0,0},
{"测量电容压差",30,2,1,1},
{"测量桥丝阻值",31,4,1,1},
{"使能OTP写",32,5,0,0},
{"写模块版本",33,5,1,0},
{"读取版本号",34,5,0,1},
{"写缓存数据",35,5,3,0},
{"验证缓存数据",36,5,3,0},
{"验证延时时间",37,5,0,0},
{"切换总线极性",38,5,2,0},
{"计算异常",39,0,10,0},
{"重新执行任务",40,0,1,0},
{"配置三码数据到小板",41,1,10,0},
{"任务插槽",42,1,1,0},
{"设置电阻校准值",43,1,1,0},
{nullptr,0,0,0,0},
};


// task_id,errcode,par_count,ret_count
static const task_def g_ext_task_table[]={
{"计算异常",100,0,10,0},
{"重新执行任务",101,0,1,0},
{"配置三码数据到小板",102,1,10,0},
{"任务插槽",103,1,1,0},
{"设置电阻校准值",104,1,1,0},
{nullptr,0,0,0,0},
};





// 根据字符找到任务,失败返回nullptr
const task_def *coder_find_task(const char *str)
{
  int chip=elec_extract_chip(check_plan()->get_plan_id());
  const task_def *table=nullptr;
  table=g_ext_task_table;
  for(int i=0;i<100;i++){
    if(qstrcmp(str,table[i].name)==0){
      return &table[i];
    }
  }
  table=nullptr;
  if(chip==0){
    table=g_jq_task_table;
  }else if(chip==2){
    table=g_ew_task_table;
  }
  if(table==nullptr){
    return nullptr;
  }
  for(int i=0;i<100;i++){
    if(qstrcmp(str,table[i].name)==0){
      return &table[i];
    }
  }
  
  return nullptr;
}


// 返回芯片类型
char coder_chip_type()
{
  int chip=elec_extract_chip(check_plan()->get_plan_id());
  const char table[]="JXW";
  if(chip>=0&&chip<=2){
    return table[chip];
  }
  return 0;
}



// 添加一个任务,返回0添加成功
int coder_add_task(myarray &d,const char *name,int slot_index,int task_index,uint16_t params[10])
{
  const task_def *task=nullptr;
  task=coder_find_task(name);
  if(task==nullptr){
    return -1;
  }
  char *par=(char *)params;
  d.append(uint8_t(slot_index));
  d.append(uint8_t(task->task_id));
  d.append(uint8_t(task->par_count));
  d.append(uint8_t(task->ret_count));
  d.append(uint8_t(task->errcode));
  d.append(uint8_t(task_index));
  d.append(par,task->par_count*2);
  return 0;
}


// 包装为一个小板的数据,返回0成功
// 包装前需要先添加任务
int coder_slave_pack(myarray &d,int addr)
{
  int len=d.size();
  d.insert(0,uint8_t(len));
  d.insert(0,uint8_t(addr));
  return 0;
}










// 检测任务需要读取模块工厂信息
myarray cmd_coder_check::cmd_pc_to_slave(myarray data)
{
  myarray d;
  // 检测模式0,返回原始检测结果
  d.insert(0,uint8_t(0));
  return d;
}

// 把从机回复的数据转化为上位机能理解的格式
myarray cmd_coder_check::ret_slave_to_pc(QList<myarray> data)
{
  myarray r;
  r.append(uint8_t(addrs));
  r.append(uint8_t(mode));
  for (int i=0;i<data.size();i++)
  {
    myarray &sdata=data[i];
    int addr=i+syscfg()->slave_addr_start;
    r.append(uint8_t(addr));
    r.append(sdata[0]);
    r.append(4,uint8_t(0));
  }
  return r;
}


static HandlePc *get_coder_check(){
  return new cmd_coder_check();
}
protpc_export(0x01, get_coder_check);














// 新检测任务需要读取模块工厂信息
myarray cmd_coder_check2::cmd_pc_to_slave(myarray data)
{
  myarray d;
  int chip=elec_extract_chip(check_plan()->get_plan_id());
  const task_def *table=nullptr;
  if(chip==0){
    uint16_t params[10]={20,4};
    coder_add_task(d,"读OTP",1,1,params);
  }else if(chip==2){
    uint16_t params[10]={9,4};
    coder_add_task(d,"读MTP",1,1,params);
  }
  coder_slave_pack(d,0x1f);
  // 检测模式1,返回异常代码和任务插槽数据
  d.insert(0,uint8_t(1));
  return d;
}

// 把从机回复的数据转化为上位机能理解的格式
myarray cmd_coder_check2::ret_slave_to_pc(QList<myarray> data)
{
  myarray r;
  r.append(uint8_t(addrs&0xff));
  r.append(uint8_t((addrs>>8)&0xff));
  r.append(uint8_t((addrs>>16)&0xff));
  r.append(uint8_t(coder_chip_type()));
  for (int i=0;i<data.size();i++)
  {
  
  }
  return r;
}


static HandlePc *get_coder_check2(){
  return new cmd_coder_check2();
}
protpc_export(0x10, get_coder_check2);










// 赋码任务需要写入uid
myarray cmd_coder_code::cmd_pc_to_slave(myarray data)
{
  myarray ret;
  const task_def *table=nullptr;
  uint16_t params[10]={0};
  for (int i=0;i<addrs;i++){
    myarray d;
    
    coder_add_task(d,"配置三码数据到小板",1,1,params);
    coder_add_task(d,"写入三码数据",1,2,params);
    coder_add_task(d,"验证三码数据",2,3,params);
    coder_slave_pack(d,i+1);
    ret+=d;
  }
  // 检测模式1,返回异常代码和任务插槽数据
  d.insert(0,uint8_t(1));
  return d;
}

// 把从机回复的数据转化为上位机能理解的格式
myarray cmd_coder_code::ret_slave_to_pc(QList<myarray> data)
{
  myarray r;
  r.append(uint8_t(addrs&0xff));
  r.append(uint8_t((addrs>>8)&0xff));
  r.append(uint8_t((addrs>>16)&0xff));
  r.append(uint8_t(coder_chip_type()));
  for (int i=0;i<data.size();i++)
  {
  
  }
  return r;
}


static HandlePc *get_coder_code(){
  return new cmd_coder_code();
}
protpc_export(0x02, get_coder_code);










// 设置电阻 校准值
myarray cmd_coder_setrtv::cmd_pc_to_slave(myarray data)
{
  myarray ret;
  const task_def *table=nullptr;
  uint16_t params[10]={0};
  int len=data.size();
  for(int i=0;i<len;i+=3){
    myarray d;
    params[0]=data[i+1]|(data[i+2]<<8);
    coder_add_task(d,"设置电阻校准值",1,1,params);
    coder_slave_pack(d,data[i]);
    ret+=d;
  }
  // 检测模式3,返回异常代码和任务插槽数据
  ret.insert(0,uint8_t(3));
  qDebug()<<"set rtv,data="<<ret.toHex(' ');
  return ret;
}

// 把从机回复的数据转化为上位机能理解的格式
myarray cmd_coder_setrtv::ret_slave_to_pc(QList<myarray> data)
{
  myarray r;
  r.append(uint8_t(0));
  return r;
}


static HandlePc *get_coder_setrtv(){
  return new cmd_coder_setrtv();
}
protpc_export(0x41, get_coder_setrtv);