#include <stdlib.h>
#include <stdio.h>
#include "sys.h"
#include "file.h"
#include "lock.h"
#include "paras.h"
#include "cascade.h"


#if 1
    #define LOGD            log_d
    #define LOGE            log_e
    #define LOGW            log_w
#else
    #define LOGD            printf
    #define LOGE            printf
    #define LOGW            printf
#endif

enum {
    INI_READ=0,
    INI_WRITE,
};

extern GlobalDeviceInfo DFLT_PARAS;

typedef struct {
    int  flag;
    
}paras_handle_t;
static paras_handle_t  paraHandle={0};



static int do_check(void *para)
{
    return 0;
}
#if 1

#include "dictionary.h"
#include "iniparser.h"

typedef struct {
    int             product_id                  ;//产品ID 
    char            product_number[16]          ;//产品编号    
    char            product_name[32]            ;//产品名称
    char            product_status[32]          ;//产品状态
    unsigned char   product_type                ;//产品类型
    unsigned char   product_pwr_type            ;//电源类型
    char            product_version[8]          ;//软件版本
    unsigned char   product_language            ;//多国语言
    unsigned char   product_count               ;//级联设备数
    unsigned short  product_samp_time           ;//采集周期 单位ms
    unsigned short  product_save_time           ;//采集周期 单位ms
}prod_info_t;

static int ini_rw_prod(int rw, dictionary *dic, GlobalDeviceInfo *info)
{
    int r=-1,ok=1;
    char *p=NULL;
    char temp[100];
    char *token=NULL;

    if(info->product_language>=4) {
        LOGE("___ product_language %d is wrong\n", info->product_language);
        ok = 0;
    }
    if(info->product_type>=2) {
        LOGE("___ product_type %d is wrong\n", info->product_type);
        ok = 0;
    }
    if(info->product_pwr_type>=SmartPDU_Tree_AC_One_B) {
        LOGE("___ product_pwr_type %d is wrong\n", info->product_pwr_type);
        ok = 0;
    }
    if(!ok) {
        return -1;
    }

    token = "product:id";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product_id = r;
    }
    else {
        sprintf(temp, "%d", info->product_id);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:number";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product_number, p);
    }
    else {
        r = iniparser_set(dic, token, info->product_number);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:name";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product_name, p);
    }
    else {
        r = iniparser_set(dic, token, info->product_name);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }
    
    token = "product:type";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product_type = r;
    }
    else {
        sprintf(temp, "%d", info->product_type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:powertype";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product_pwr_type = r;
    }
    else {
        sprintf(temp, "%d", info->product_pwr_type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:version";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        strcpy(info->product_version, p);
    }
    else {
        r = iniparser_set(dic, token, info->product_version);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:language";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getint %s failed\n", token);
            return -1; 
        }
        info->product_language = r;
    }
    else {
        sprintf(temp, "%d", info->product_language);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:samptime";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product_samp_time = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product_samp_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "product:savetime";
    if(rw==INI_READ) {
        p = (char*)iniparser_getstring(dic, token, NULL);
        if(!p) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        info->product_save_time = atoi(p);
    }
    else {
        sprintf(temp, "%d", info->product_save_time);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    if(rw==INI_READ) {
        info->product_count = 0;
        info->product_status[0] = 0;
    }
    
    return 0;
}
static int ini_rw_modbus(int rw, dictionary *dic, GlobalDeviceInfo *info)
{
    int r=-1;
    char temp[100];
    char *token=NULL;
    ModbusInfo_t *mb=&info->_modbus_info;

    if(rw==INI_WRITE) {
        if(mb->product_modbus_type!=0 || mb->product_modbus_type!=1) {
            LOGE("___ set modbus, mode %d is invalid\n", mb->product_modbus_type);
            return -1; 
        }

        if(mb->product_modbus_type==1 && (mb->product_modbus_addr==0 || mb->product_modbus_addr>CASCADE_MAX)) {    //slave
            LOGE("___ set modbus, slave addr %d is invalid\n", mb->product_modbus_addr);
        }
    }

    token = "modbus:mode";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->product_modbus_type = r;
    }
    else {
        sprintf(temp, "%d", mb->product_modbus_type);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:baudrate";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->product_modbus_baud = r;
    }
    else {
        sprintf(temp, "%d", mb->product_modbus_baud);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    token = "modbus:address";
    if(rw==INI_READ) {
        r = iniparser_getint(dic, token, -1);
        if(r==-1) {
            LOGE("___ iniparser_getstring %s failed\n", token);
            return -1; 
        }
        mb->product_modbus_addr = r;
    }
    else {
        sprintf(temp, "%d", mb->product_modbus_addr);
        r = iniparser_set(dic, token, temp);
        if(r) {
            LOGE("___ iniparser_set %s failed\n", token);
            return -1;
        }
    }

    return 0;
}
static int ini_rw_network(int rw, dictionary *dic, GlobalDeviceInfo *info)
{
    int r=-1;
    char *p=NULL;
    char temp[100];
    char *token=NULL;

    return 0;
}
static int ini_reset(void)
{
    int r;
    dictionary *dic=NULL;
    char *ininame=INI_FILE_NAME;
    char temp[200];
    FILE *fp=NULL;
    GlobalDeviceInfo *info=&DFLT_PARAS;

    sys_get_path(temp, ininame);
    fp = fopen(temp, "w");
    if (fp==NULL) {
        LOGE("ini_reset, create %s failed\n", ininame);
        return -1;
    }

    fprintf(fp, "[product]\n");
    fprintf(fp, "id        = %d\n", info->product_id);
    fprintf(fp, "number    = %s\n", info->product_number);
    fprintf(fp, "name      = %s\n", info->product_name);
    fprintf(fp, "type      = %d\n", info->product_type);
    fprintf(fp, "powertype = %d\n", info->product_pwr_type);
    fprintf(fp, "version   = %s\n", info->product_version);
    fprintf(fp, "language  = %d\n", info->product_language);
    fprintf(fp, "samptime  = %d\n", info->product_samp_time);
    fprintf(fp, "savetime  = %d\n", info->product_save_time);
    fclose(fp);

    return 0;
}
static int ini_load(GlobalDeviceInfo *info)
{
    int r=-1;
    char *p=NULL;
    char *ininame=INI_FILE_NAME;
    
    dictionary *dic=iniparser_load(ininame);
    if(dic == NULL){
        ini_reset();
        dic = iniparser_load(ininame);
        if(dic == NULL) {
            LOGE("___ iniparser_load failed\n");
            return -1;
        }
    }
    
    r = ini_rw_prod(INI_READ, dic, info);
    if(r) {
        LOGE("___ini_r_prod failed\n");
    }
    iniparser_freedict(dic);

    return r;
}
static int ini_save(GlobalDeviceInfo *info)
{
    int r=-1;
    char *p=NULL;
    char temp[200];
    char *ininame=INI_FILE_NAME;
    
    dictionary *dic=iniparser_load(ininame);
    if(dic == NULL){
        LOGE("___ %s load failed\n", ininame);
        return -1;
    }
    
    r = ini_rw_prod(INI_WRITE, dic, info);
    if(r) {
        LOGE("___ini_r_prod failed\n");
        goto quit;
    }

    sys_get_path(temp, ininame);
    FILE *fp=fopen(temp, "w");
    if(!fp) {
        LOGE("___%s open failed\n", ininame);
        goto quit;
    }
    iniparser_dump_ini(dic, fp);
    fclose(fp);

quit:
    iniparser_freedict(dic);
    return r;
}
#endif

static GlobalDeviceInfo *get_dm(void)
{
    return &__globalDeviceManage._globalDevInfo;
}
////////////////////////////////////////////////////////////


int paras_init(void)
{
    GlobalDeviceInfo *info=get_dm();
    paras_handle_t  *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_load(info);
    lock_s_release(LOCK_ID_PARAS);
    
    return 0;
}


int paras_deinit(void)
{
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    memset(&paraHandle, 0, sizeof(paraHandle));
    lock_s_release(LOCK_ID_PARAS);
    
    return 0;
}


int paras_load(void)
{
    int r=0;
    GlobalDeviceInfo *info=get_dm();
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    r = ini_load(info);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_reset(void)
{
    int r=0;
    GlobalDeviceInfo *info=get_dm();
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    ini_reset();
    r = ini_load(info);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_save(void)
{
    int r=0;
    GlobalDeviceInfo *info=get_dm();
    paras_handle_t *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    //r = ini_save(info);
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_read(int type, void *data)
{
    int r=0;
    paras_handle_t  *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}


int paras_write(int type, void *data)
{
    int r=0;
    paras_handle_t  *h=&paraHandle;
    
    lock_s_hold(LOCK_ID_PARAS);
    
    lock_s_release(LOCK_ID_PARAS);
    
    return r;
}