#include "myjson.h"
#include "board.h"
#include "debug.h"
#include "mystdlib.h"
#include "bytearray.h"





// json字符串转化为json,返回临时指针
cJSON *json_parse(const char *jstr)
{
  cJSON *json=cJSON_Parse(jstr);
  if(json){
    return tappend(json,cJSON_Delete);
  }
  return json;
}






/*r{ json 转列表 }c*/
list_def *jarray_to_list(cJSON *jarray,obj_def *obj)
{
  param_check(obj);
  param_check(obj->to_obj_fun);
  param_check(obj->obj_size);
  param_check(jarray);
  list_def *l=list_creat(obj->obj_size,obj->sub,obj->del,0);
  void *o;
  int array_size;
  if(jarray->type!=cJSON_Array){
    DBG_WARN("json:%s not a array obj.",jarray->string?jarray->string:"null");
    goto err;
  }
  array_size=cJSON_GetArraySize(jarray);
  for(int i=0;i<array_size;i++)
  {
    o=obj->to_obj_fun(cJSON_GetArrayItem(jarray,i));
    if(o==0)
    {
      DBG_WARN("json:%s conversion failed.",jarray->string?jarray->string:"null");
      goto err;
    }
    list_append(l,o);
    if(obj->del_fun) obj->del_fun(o);
  }
  err:
  return l;
}


/*r{ json转整形 }c*/
static void *json_to_int(cJSON *j)
{
  if(j->type==cJSON_Number)
  {
    int *ret=malloc(sizeof(int));
    param_check(ret);
    *ret=j->valueint;
    return ret;
  }
  return 0;
}



static obj_def g_obj_int={
  .obj_size=sizeof(int),
  .to_obj_fun=json_to_int,
  .del_fun=free,
  .sub=INT_SUB,
  .del=INT_DEL
};


obj_def *obj_int(void)
{
  return &g_obj_int;
}








/*r{ json转字符串 }c*/
static void *json_to_str(cJSON *j)
{
  if(j->type==cJSON_String)
  {
    int len=strlen(j->valuestring)+1;
    char *ret=malloc(len);
    char **ret_ptr=malloc(sizeof(char *));
    param_check(ret);
    param_check(ret_ptr);
    memcpy(ret,j->valuestring,len+1);
    *ret_ptr=ret;
    return ret_ptr;
  }
  return 0;
}



static obj_def g_obj_str={
  .obj_size=sizeof(char *),
  .to_obj_fun=json_to_str,
  .del_fun=free,
  .sub=STR_SUB,
  .del=STR_DEL
};


obj_def *obj_str(void)
{
  return &g_obj_str;
}





static void *json_to_range(cJSON *j)
{
  sch_range *s=malloc(sizeof(sch_range));
  param_check(s);
  JSON_GET_INT(cJSON_GetObjectItem(j,"Max"),s->max);
  JSON_GET_INT(cJSON_GetObjectItem(j,"Min"),s->min);
  if(s->min>s->max){
    DBG_WARN("range is empty.");
  }
  return s;
}





static obj_def g_obj_range={
  .obj_size=sizeof(sch_range),
  .to_obj_fun=json_to_range,
  .del_fun=free,
  .sub=0,
  .del=0
};


obj_def *obj_range(void)
{
  return &g_obj_range;
}

// 返回1，在范围内
int range_in_range(sch_range *r,int num)
{
  if(num>=r->min&&num<=r->max)
    return 1;
  else
    return 0;
}








static void *json_to_task(cJSON *j)
{
  sch_task *task=calloc(1,sizeof(sch_range));
  JSON_GET_STR(cJSON_GetObjectItem(j,"TaskBrief"),task->brief);
  JSON_GET_INT(cJSON_GetObjectItem(j,"TaskID"),task->task_id);
  JSON_GET_INT(cJSON_GetObjectItem(j,"TaskIndex"),task->index);
  JSON_GET_INT(cJSON_GetObjectItem(j,"ErrJumpTo"),task->err_jump);
  JSON_GET_INT(cJSON_GetObjectItem(j,"RetryCount"),task->retry);
  JSON_GET_INT(cJSON_GetObjectItem(j,"ParamCount"),task->param_num);
  JSON_GET_INT(cJSON_GetObjectItem(j,"ReturnCount"),task->return_num);
  task->params_info=jarray_to_list(cJSON_GetObjectItem(j,"ParamInfo"),obj_str());
  task->returns_info=jarray_to_list(cJSON_GetObjectItem(j,"ReturnInfo"),obj_str());
  task->params=jarray_to_list(cJSON_GetObjectItem(j,"ParamVal"),obj_int());
  task->ranges=jarray_to_list(cJSON_GetObjectItem(j,"TestStandard"),obj_range());
  JSON_GET_INT(cJSON_GetObjectItem(j,"ExecuteErrCode"),task->failed_code);
  task->ret_failed_code=jarray_to_list(cJSON_GetObjectItem(j,"ResultErrCode"),obj_int());
  return task;
}




static int _list_del_task(void *p)
{
  sch_task *t=p;
  CHECK_DO(t->brief,free);
  CHECK_DO(t->params_info,list_delete);
  CHECK_DO(t->returns_info,list_delete);
  CHECK_DO(t->params,list_delete);
  CHECK_DO(t->ranges,list_delete);
  CHECK_DO(t->ret_failed_code,list_delete);
  CHECK_DO(t->ch_errcode,list_delete);
  return 0;
}



static obj_def g_obj_task={
  .obj_size=sizeof(sch_task),
  .to_obj_fun=json_to_task,
  .del_fun=free,
  .sub=0,
  .del=_list_del_task
};


obj_def *obj_task(void)
{
  return &g_obj_task;
}

// 任务转化为数组
array_def *task_to_array(sch_task *t)
{
  array_def *a=arr_creat();
  arr_append(a,(uint8_t)t->task_id);
  arr_append(a,(uint8_t)t->index);
  arr_append(a,(uint8_t)t->retry);
  arr_append(a,(uint8_t)t->err_jump);
  arr_append(a,(uint8_t)(t->param_num&0x0f)|(t->return_num<<4));
  for(int i=0;i<list_length(t->params);i++)
  {
    arr_append(a,(uint8_t)(list_get_int(t->params,i)&0xff));
    arr_append(a,(uint8_t)(list_get_int(t->params,i)>>8));
  }
  if(list_length(t->params)!=t->param_num)
  {
    DBG_WARN("name=%s param_num!=params.size().",t->brief);
  }
  if(t->return_num>list_length(t->returns_info))
  {
    DBG_WARN("name=%s return_num>returns_info.size().",t->brief);
  }
  if(list_length(t->ch_errcode)!=list_length(t->ranges))
  {
    DBG_WARN("name=%s ch_errcode.size()!=ranges.size().",t->brief);
  }
  return a;
}



// ack==0成功
task_returns *task_check_returns(sch_task *t,int ack,array_def *data)
{
  int size=sizeof(task_returns)+sizeof(reurn_item)*t->return_num;
  task_returns *res=malloc(size);
  param_check(res);
  res->size=size;
  memset(res,0,size);
  if(t->ch_errcode==0) t->ch_errcode=list_creat_int();
  list_clear(t->ch_errcode);
  res->index=t->index;
  res->id=t->task_id;
  res->ack=ack;
  if(res->ack==0){
    res->exe_err=0;
  }else{
    res->exe_err=t->failed_code;
    list_append_int(t->ch_errcode,t->failed_code);
  }
  if(arr_length(data)/2<t->return_num){
    DBG_WARN("task=%s, data size too less.",t->brief);
  }else{
    for(int i=0;i<t->return_num;i++)
    {
      reurn_item *item=&res->items[i];
      int value=arr_get(data,i*2)|(arr_get(data,i*2+1)<<8);
      item->value=value;
      if(list_length(t->ranges)>i)
      {
        if(range_in_range(list_get(t->ranges,i),value))
          item->err=0;
        else{
          if(list_length(t->ret_failed_code)>i)
          {
            item->err=list_get_int(t->ret_failed_code,i);
            list_append_int(t->ch_errcode,item->err);
          }
        }
      }
    }
  }
  return res;
}





static void *json_to_errcode(cJSON *j)
{
  sch_errcode *e=calloc(1,sizeof(sch_errcode));
  param_check(e);
  JSON_GET_INT(cJSON_GetObjectItem(j,"MajorErrCode"),e->err);
  JSON_GET_STR(cJSON_GetObjectItem(j,"Info"),e->info);
  e->suberr=jarray_to_list(cJSON_GetObjectItem(j,"SubErrCode"),obj_int());
  return e;
}

static int _list_del_errcode(void *p)
{
  sch_errcode *e=p;
  CHECK_DO(e->info,free);
  CHECK_DO(e->suberr,list_delete);
  return 0;
}

static obj_def g_obj_errcode={
  .obj_size=sizeof(sch_errcode),
  .to_obj_fun=json_to_errcode,
  .del_fun=free,
  .sub=0,
  .del=_list_del_errcode
};


obj_def *obj_errcode(void)
{
  return &g_obj_errcode;
}

// 返回1在范围内
int errcode_in_range(sch_errcode *e,int subcode)
{
  param_check(e);
  for(int i=0;i<list_length(e->suberr);i++)
  {
    if(subcode==list_get_int(e->suberr,i))
      return 1;
  }
  return 0;
}





static void *_json_to_scheme(cJSON *j)
{
  scheme_def *s=calloc(1,sizeof(scheme_def));
  param_check(s);
  JSON_GET_INT(cJSON_GetObjectItem(j,"PlanID"),s->plan_id);
  JSON_GET_STR(cJSON_GetObjectItem(j,"PlanBrief"),s->brief);
  s->slave_soft_versions=jarray_to_list(cJSON_GetObjectItem(j,"CheckSoftVersion"),obj_int());
  s->slave_hard_versions=jarray_to_list(cJSON_GetObjectItem(j,"CheckHardVersion"),obj_int());
  JSON_GET_INT(cJSON_GetObjectItem(j,"TimeOutS"),s->timeout_s);
  JSON_GET_INT(cJSON_GetObjectItem(j,"TimeOutM"),s->timeout_m);
  JSON_GET_INT(cJSON_GetObjectItem(j,"TaskIDMax"),s->task_id_max);
  s->errs=jarray_to_list(cJSON_GetObjectItem(j,"MajorErrInfo"),obj_errcode());
  s->tasks=jarray_to_list(cJSON_GetObjectItem(j,"TaskArray"),obj_task());
  return s;
}



static int _list_del_scheme(void *p)
{
  scheme_def *t=p;
  CHECK_DO(t->brief,free);
  CHECK_DO(t->slave_soft_versions,list_delete);
  CHECK_DO(t->slave_hard_versions,list_delete);
  CHECK_DO(t->errs,list_delete);
  CHECK_DO(t->tasks,list_delete);
  CHECK_DO(t->ch_errcode,list_delete);
  return 0;
}

static obj_def g_obj_scheme={
  .obj_size=sizeof(scheme_def),
  .to_obj_fun=_json_to_scheme,
  .del_fun=free,
  .sub=0,
  .del=_list_del_scheme
};


obj_def *obj_scheme(void)
{
  return &g_obj_scheme;
}



scheme_def *json_to_scheme(cJSON *j)
{
  param_check(j);
  obj_def *obj=obj_scheme();
  scheme_def *s=obj->to_obj_fun(j);
  return s;
}
void scheme_delete(scheme_def *s)
{
  obj_def *obj=obj_scheme();
  param_check(s);
  obj->del(s);
  obj->del_fun(s);
}


// 任务id转化为字节数据
#define TASKSID_MAX_SIZE 0x100
static array_def *scheme_taskid_to_array(scheme_def *s)
{
  param_check(s);
  array_def *res=arr_creat();
  param_check(res);
  arr_append(res,s->plan_id&0xff);
  arr_append(res,(s->plan_id>>8)&0xff);
  arr_append(res,(s->plan_id>>16)&0xff);
  arr_append(res,(s->plan_id>>24)&0xff);
  for(int i=0;i<list_length(s->tasks);i++)
  {
    sch_task *t=list_get(s->tasks,i);
    arr_append(res,t->task_id);
  }
  int size=arr_length(res);
  if(size<TASKSID_MAX_SIZE){
    arr_append_num(res,TASKSID_MAX_SIZE-size,0xff);
  }else{
    DBG_WARN("taskid array size too larg.");
  }
  return res;
}

// 任务转化为字节数据
#define TASKS_MAX_SIZE (0x700-4)
static array_def *scheme_tasks_to_array(scheme_def *s)
{
  param_check(s);
  array_def *res=arr_creat();
  param_check(res);
  for(int i=0;i<list_length(s->tasks);i++)
  {
    sch_task *t=list_get(s->tasks,i);
    array_def *a=task_to_array(t);
    arr_appends_from(res,a);
    arr_delete(a);
  }
  int size=arr_length(res);
  if(size<TASKS_MAX_SIZE)
  {
    arr_append_num(res,TASKS_MAX_SIZE-size,0xff);
  }else{
    DBG_WARN("tasks array size too larg.");
  }
  return res;
}

// 方案转化为字节数据
array_def *scheme_to_byte_array(scheme_def *s)
{
  param_check(s);
  array_def *res=arr_creat();
  param_check(res);
  array_def *src;
  src=scheme_taskid_to_array(s);
  arr_appends_from(res,src);
  arr_delete(src);
  src=scheme_tasks_to_array(s);
  arr_appends_from(res,src);
  arr_delete(src);
  return res;
}


// 统计返回数据长度
int scheme_get_returns_num(scheme_def *s)
{
  int num=0;
  for(int i=0;i<list_length(s->tasks);i++)
  {
    sch_task *t=list_get(s->tasks,i);
    num+=t->return_num;
  }
  return num;
}

// 返回0成功，1失败
int scheme_check_ack(array_def *data,int index)
{
  param_check(index>=0);
  param_check(index<arr_length(data)*8);
  uint8_t temp=arr_get(data,index/8);
  if((temp&(1<<(index%8)))!=0)
  {return 1;}else{return 0;}
}

// 返回子错误所在的主错误，失败返回0
int scheme_fine_majercode(scheme_def *s,int subcode)
{
  for(int i=0;i<list_length(s->errs);i++)
  {
    sch_errcode *e=list_get(s->errs,i);
    if(errcode_in_range(e,subcode))
      return e->err;
  }
  return 0;
}


// 判定检测数据
scheme_returns *scheme_check_returns(scheme_def *s,array_def *data)
{
  int size=0;
  size+=sizeof(scheme_returns);
  size+=sizeof(task_returns)*list_length(s->tasks);
  size+=sizeof(reurn_item)*scheme_get_returns_num(s);
  scheme_returns *res=malloc(size);
  param_check(res);
  memset(res,0,size);
  res->size=size;
  if(s->ch_errcode==0) s->ch_errcode= list_creat_int();
  list_clear(s->ch_errcode);
  
  int start=16;
  int off=0;
  for(int i=0;i<list_length(s->tasks);i++)
  {
    int ack=scheme_check_ack(data,i);
    sch_task *t=list_get(s->tasks,i);
    array_def *arr_temp=arr_mid(data,start,t->return_num*2);
    task_returns *task_ret=task_check_returns(t,ack,arr_temp);
    arr_delete(arr_temp);
    memcpy(&res->data[off],task_ret,task_ret->size);
    off+=task_ret->size;
    start+=t->return_num*2;
    list_append_from(s->ch_errcode,t->ch_errcode);
  }
  if(list_length(s->ch_errcode)>0)
  {
    res->errcode=scheme_fine_majercode(s,list_get_int(s->ch_errcode,0));
  }else{
    res->errcode=0;
  }
  return res;
}