#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找到任务
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;
}

// 获取任务index的参数


// 获取第index个范围
static int get_range(int index,int *min,int *max)
{
  const scheme_def *s=check_scheme();
  const scheme_task_def *t;
  int index_p=0;
  for(int i=0;i<s->task_num;i++)
  {
    t=&s->task[i];
    for(int j=0;j<t->item_num;j++)
    {
      if(index_p==index)
      {
        if(min) *min=t->range[j].min;
        if(max) *max=t->range[j].max;
        return index_p;
      }
      index_p++;
    }
  }
  return index_p;
}


// 获取第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
//-- 过流，7
//-- 短路，8

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

uint8_t coder_judge(const uint8_t *data)
{
  int temp,temp2;
  int index=0;
  const scheme_task_def *task=0;
  
  // 开总线
  task=find_task_next(index,0);
  TASK_RETURN(task);
  {
    if(get_ack(data,0))
    {
      // 上电错误，检测器异常
      return 1;
    }
  }
  
  // 上电充能
  task=find_task_next(index,1);
  TASK_RETURN(task);
  {
    temp=get_data(data,0);
    if(temp<task->range[0].min)
    {
      // 电压无法上升，检测器异常
      return 1;
    }
    temp=get_data(data,1);
    if((temp>39000)||(temp<1)){
      // 充能失败，检测电流
    }
  }
  
  // 检测电流
  task=find_task_next(index,4);
  TASK_RETURN(task);
  temp=get_data(data,5);
  temp2=get_data(data,6);
  if((temp<10)&&(temp2<20))
  {
    // 接触异常
    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;
  }
  
  
  // 检测uid
  task=find_task_next(index,5);
  TASK_RETURN(task);
  if(get_ack(data,task->taskindex))
  {
    // 芯片错误
    return 5;
  }
  
  // 检测桥丝
  task=find_task_next(index,6);
  TASK_RETURN(task);
  temp=get_data(data,7);
  if((temp<task->range[0].min)||(temp>task->range[0].max))
  {
    // 桥丝错误
    return 4;
  }
  
  // 检测
  
  
  return 0;
}