#ifndef __CASCADE_Hx__
#define __CASCADE_Hx__

#include <stdint.h>
#include "common.h"
#include "json_handle.h"
#include "xlist.h"




#define MAX_BREAKER_CHN                 (6)
#define MAX_BREAKER_ID                  (49) 

#define CASCADE_MAX                     32
#define ERR_MAX                         5
#define CH_MAX                          128

#define MAX_READ_REGS                   1000
#define MAX_WRITE_REGS                  1000

#define MAX_READ_REGS2                  50000
#define MAX_WRITE_REGS2                 50000


#define CASCADE_REG_OFFSET              0x10

#define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0)
#define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+1)
#define CASCADE_REG_SCAN                (CASCADE_REG_OFFSET+2)

// #define CASCADE_REG_BREAKER             0x40

// #define CASCADE_REG_BREAKER_READ            (CASCADE_REG_BREAKER+0)
// #define CASCADE_REG_BREAKER_WRITE       (CASCADE_REG_BREAKER+1)



enum {
    CASCADE_CMD_OPEN=0,
    CASCADE_CMD_CLOSE,
    CASCADE_CMD_SAVE,
    CASCADE_CMD_SAVE3,

    CASCADE_CMD_GET_INFO,

    CASCADE_CMD_QUERY_CH,
    CASCADE_CMD_QUERY_VOL,
    CASCADE_CMD_QUERY_CUR,
    CASCADE_CMD_QUERY_PWR,
    CASCADE_CMD_QUERY_PWRQ,
    CASCADE_CMD_QUERY_HIS,
    CASCADE_CMD_QUERY_TOTAL,
    CASCADE_CMD_QUERY_TOTAL_PWR,

    CASCADE_CMD_BREAKER_QUERY,
    CASCADE_CMD_GET_BREAKER_INFO,
    CASCADE_CMD_BREAKER_SAVE_ADD,
    CASCADE_CMD_BREAKER_SAVE_UPDATE,
    CASCADE_CMD_BREAKER_SAVE_DELETE,
    CASCADE_CMD_OPEN_NF,
    CASCADE_CMD_CLOSE_NF,

    CASCADE_CMD_MAX,
};

#pragma pack (1)

typedef struct {
    int       addr;
    int       err;      //err times
}slave_t;

typedef struct {
    slave_t   *slave;
    int       cnt;
}dev_list_t;

typedef struct {
    uint16_t deveice_type;          //设备类型
    uint16_t slave_addr;            //设备地址
    uint32_t voltage;               //当前电压
    uint32_t current;               //当前电流
    uint32_t power;                 //当前功率
    uint32_t consumption;           //耗电量
    uint32_t freq;                  //频率
    uint32_t factor;                //功率因素
    uint32_t temprature;            //温度值
    uint32_t humidity;              //湿度值
    uint32_t warning;               //告警
    uint16_t power_status;          //供电状态
    uint16_t sensor_status;         //传感器状态

    //uint32_t Warinfo;
    //uint16_t sersor_type;
}sensor_ori_t;

typedef struct {
    int   type;                  //设备类型
    int   addr;

    PowerInfo pwr;

    float temprature;            //温度值
    float humidity;              //湿度值
    int   warning;               //告警
    int   power_status;          //供电状态
    int   sensor_status;         //传感器状态
}sensor_data_t;


enum {
    TYPE_CMD=0,
    TYPE_FILE,
};

enum {
    OBJ_OVERALL=0,
    OBJ_CHANNEL,
    OBJ_HISTORY,
    OBJ_SENSOR,
};

typedef struct {
    int             dlen;
    uint8_t         *data;           
}data_t;


typedef struct {
    uint8_t         product_type;
    uint8_t         product_pwr_type;
    uint8_t         product_id;
}product_info_t;

typedef struct {
    uint8_t         product_ph_id;
    uint8_t         product_ph_type;        //0:A相 1:B相 2:C相
    uint8_t         product_ph_outputType;  //三相控制方式1,三项2单项
    uint8_t         product_ph_outputStatus;//该相是否输出，1输出2不输出
}phase_info_t;

typedef struct {
    PowerInfo       power;
    phase_info_t    phase;
}power_info_t;

typedef struct {
    uint8_t         product_saddr;
    uint8_t         product_ch_type;
    uint8_t         product_ch_addr;
    uint8_t         product_ch_id;
    uint8_t         product_ch_status;
    uint8_t         product_ch_NF_status;
    
    PowerInfo       chinfo;
    power_info_t    pinfo[3];
    uint16_t        start_delay;
    uint16_t        stop_delay;
}channel_info_t;

typedef struct {
    PowerInfo       power[3];
}overall_info_t;

typedef struct {
    uint8_t         cnt;
    product_info_t  prod;
    overall_info_t  all;
    channel_info_t  ch[CH_MAX];
}slave_info_t;


// slave breaker information
typedef struct{
    //uint8_t  breaker_addrs;
    uint8_t  product_id;
    uint8_t  breaker_chn;
    uint16_t breaker_status;
    uint16_t breaker_addrs;
    int breaker_id;
    char breaker_gather_type[6];
    char breaker_com[20];
    char breaker_switch_name[64];
    char breaker_chns_name[64];    //
}breaker_channel_info_t;


typedef struct {
    int cnt;
    breaker_channel_info_t breaker_chn[CH_MAX];
}breaker_info_t;


typedef struct{
    uint8_t jdh;
    uint8_t cjdz;
    char com[32];
    char cjfs[20];
    char breaker_chns[64];
}cascade_breaker_add_t;

typedef struct{
    int switch_id;
    char switch_name[32];
    char breaker_chns[64];
}cascade_breaker_update_t;
typedef struct {
    int switch_id;
}cascade_braeker_delete_t;

typedef struct {
    uint8_t         cmd;
    uint8_t         obj;
    uint8_t         chId;
    // char            time_s[24];   //start time
    // char            time_e[24];   //end time
    union{
        cascade_breaker_add_t     data;
        cascade_breaker_update_t data1;
        cascade_braeker_delete_t data2;
    }datas;
}cmd_data_t;

typedef struct {
    uint8_t         tp;
    uint16_t        pid;
    uint16_t        dlen;
    uint8_t         *data;
}file_data_t;

typedef struct {
    int8_t          type;
    uint8_t         data[0];
}mb_pkt_t;

typedef struct {
    uint8_t         addr;
    uint8_t         func;
    uint16_t        reg;
    uint16_t        regcnt;
    uint8_t         dlen;
    uint8_t         *data;
}mb_hdr_t;

#pragma pack ()

////////slave define////////////////////
typedef struct mmap_modbus{
    int offset;
    void *addr;             //libmodbus source   addr 
}mmap_modbus_t;
//////////////////////////////////////

extern int cur_dev_addr;

int cascade_init(void);
int cascade_deinit(void);

int cascade_request(cmd_data_t *cmd);
int cascade_get_all(_OverAllPwrAckInfo *all);
int cascade_get_ch(_OverChnPwrAckInfo *ch);

int cascade_get_dlist(dev_list_t *dl);
int cascade_free_dlist(dev_list_t *dl);
int cascade_set_modbus(ModbusInfo_t *info);

int cascade_lock(void);
int cascade_unlock(void);

int cascade_slave_init(void);
modbus_mapping_t    *cascade_slave_map();
void cascade_slave_read(uint32_t addr,uint32_t lenth);
void cascade_slave_write(uint32_t addr, uint16_t val);

#endif