#include "coder_judge.h"
#include "dev_flash.h"
#include "string.h"


// 把d插入 a中，不允许重复
static void c_insert(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d)
      return;
  }
  for(int i=0;i<len;i++)
  {
    if(a[i]==0xff){
      a[i]=d;
      return;
    }
  }
}

// 删除a中的值d
static void c_del(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d){
      memcpy(&a[i],&a[i+1],len-i-1);
      return;
    }
  }
}


// 删除a中除d之外的所有值
static void c_only(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d)
    {
      memset(a,0xff,len);
      a[0]=d;
      return;
    }
  }
  // 如果没找到则全部删除
  memset(a,0xff,len);
}

// 初始化a
static void c_init(uint8_t *a)
{
  int len=sizeof(uint8_t [6]);
  memset(a,0xff,len);
}


// 根据taskid找到任务
static const scheme_task_def *find_task_next(int index_now,int taskid)
{
  const scheme_def *s=check_scheme();
  const scheme_task_def *t;
  for(int i=index_now;i<s->task_num;i++)
  {
    t=&s->task[i];
    if(t->taskid==taskid)
      return t;
  }
  return 0;
}





// 计算在taskindex之前有多少个返回值
static int calc_skip_num(int index)
{
  const scheme_def *s=check_scheme();
  const scheme_task_def *t;
  int num=0;
  for(int i=0;i<index;i++)
  {
    t=&s->task[i];
    num+=t->item_num;
  }
  return num;
}


// 获取第index个检测数据
static int get_data(const uint8_t *data,int index)
{
  data+=16;
  return data[index*2]|(data[index*2+1]<<8);
}

// 获取第index个任务是否成功1，失败，0成功
static int get_ack(const uint8_t *data,int index)
{
  if(data[index/8]&(1<<(index%8)))
    return 1;
  else
    return 0;
}


//-- 检测器异常,1
//-- 主电容异常,2
//-- 接触异常,3
//-- 桥丝阻值异常,4
//-- 芯片异常,5
//-- 判定任务缺失,6
//-- 过流,7
//-- 短路,8

#define  TASK_FIND_NEXT(taskid) {\
  task=find_task_next(index,taskid);\
  if(task==0) return 6; \
  else index+=1;\
}// 找不到方案

#define TASK_DATA(index) get_data(data,calc_skip_num(task->taskindex)+(index))


uint8_t coder_judge(const uint8_t *data)
{
  int temp,temp2;
  int index=0;
  const scheme_task_def *task=0;
  
  // 开总线
  TASK_FIND_NEXT(0);
  {
    if(get_ack(data,0))
    {
      // 上电错误，检测器异常
      return 1;
    }
  }
  
  // 上电充能
  TASK_FIND_NEXT(1);
  {
    temp=TASK_DATA(0);
    if(temp<task->range[0].min)
    {
      // 电压无法上升，检测器异常
      return 1;
    }
    temp=TASK_DATA(1);
    if((temp>39000)||(temp<1)){
      // 充能失败，检测电流
    }
  }
  
  // 检测电流
  TASK_FIND_NEXT(3);
  temp=TASK_DATA(0);
  temp2=TASK_DATA(1);
  if((temp<100)&&(temp2<100))
  {
    // 接触异常
    return 3;
  }
  else if(((temp>task->range[0].max)&&(temp<800))||
    ((temp2>task->range[0].max)&&(temp2<800)))
  {
    // 过流
    return 7;
  }else if((temp>800)&&(temp2>800))
  {
    // 短路
    return 8;
  }
  
  
  // 检测uid
  TASK_FIND_NEXT(4);
  if(get_ack(data,task->taskindex))
  {
    // 芯片错误
    return 5;
  }
  
  // 检测桥丝
  TASK_FIND_NEXT(11);
  temp=TASK_DATA(0);
  if((temp<task->range[0].min)||(temp>task->range[0].max))
  {
    // 桥丝错误
    return 4;
  }
  
  // 检测电容
  TASK_FIND_NEXT(12);
  temp=TASK_DATA(0);
  if((temp>task->range[0].max)||(temp<task->range[0].min))
  {
    return 2;
  }
//  temp=TASK_DATA(1);
//  if((temp>task->range[1].max)||(temp<task->range[1].min))
//  {
//    return 2;
//  }
//  temp=TASK_DATA(2);
//  if((temp>task->range[2].max)||(temp<task->range[2].min))
//  {
//    return 2;
//  }
  
  return 0;
}




uint8_t coder_judge_jq(const uint8_t *data)
{
  int temp,temp2;
  int index=0;
  const scheme_task_def *task=0;
  
  // 开总线
  TASK_FIND_NEXT(0);
  {
    if(get_ack(data,0))
    {
      // 上电错误，检测器异常
      return 1;
    }
  }
  
  // 上电充能
  TASK_FIND_NEXT(1);
  {
    temp=TASK_DATA(0);
    if(temp<task->range[0].min)
    {
      // 电压无法上升，检测器异常
      return 1;
    }
    temp=TASK_DATA(1);
    if((temp>39000)||(temp<1)){
      // 充能失败，检测电流
    }
  }
  
  // 检测uid
  int chip_err=0;
  TASK_FIND_NEXT(4);
  if(get_ack(data,task->taskindex))
  {
    // 芯片错误
    chip_err=5;
  }

  // 检测电流
  TASK_FIND_NEXT(3);
  temp=TASK_DATA(0);
  temp2=TASK_DATA(1);
  if((temp<10)&&(temp2<10))
  {
    // 接触异常
    return 3;
  }
  else if(((temp>task->range[0].max)&&(temp<1500))||
    ((temp2>task->range[0].max)&&(temp2<1500)))
  {
    // 过流
    return 7;
  }else if((temp>1500)&&(temp2>1500))
  {
    // 短路
    return 8;
  }
  
  // 芯片异常时直接报芯片异常
  if(chip_err)
    return chip_err;
  
  // 检测电容
  TASK_FIND_NEXT(11);
  temp=TASK_DATA(1);
  if((temp>task->range[1].max)||(temp<task->range[1].min))
  {
    return 2;
  }
  temp=TASK_DATA(2);
  if((temp>task->range[2].max)||(temp<task->range[2].min))
  {
    return 2;
  }
  
  // 检测桥丝
//  TASK_FIND_NEXT(11);
//  temp=TASK_DATA(1);
//  if(get_ack(data,index)){
//    return 4;
//  }
//  if((temp>task->range[1].max)||(temp<task->range[1].min))
//  {
//    return 4;
//  }

  
  return chip_err;
}




// 根据方案获取模块芯片类型
int coder_extract_chip(int id)
{
  const scheme_def *s=check_scheme();
  if(id==0) id=s->plan_id;
  // 日bit0~bit4 月bit5~bit8 年bit9~bit15
  int sid=(id>>0)&0x7f;
  int modele=(id>>7)&0x1f;
  int chip=(id>>12)&0xf;
  int day=(id>>16)&0x1f;
  int month=(id>>21)&0xf;
  int year=((id>>25)&0x7f)+2022;
  return chip;
}




