#include "mc0051gs.h"
#include "plt.h"

static void mc0051gs_comm_0xA30B(int idx)
{
    unsigned short tab_us[128] = {0};
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int start, nb, rc, i;
    int ret = 0;

    if (comm_get_state(comm) != COMMST_NORMAL)
    {
        return;
    }

    nb = 2;
    start = 0x0400;
    chan_lock(chanidx);
    rc = chan_read_holdingregisters_with_retry(chanidx, addr, start, nb, tab_us);
    chan_unlock(chanidx);
    if (rc < 0)
    {
        comm_set_state(comm, COMMST_ERR);
        return;
    }
    else if (rc == 0)
    { /* read ok */
        const int started_idx = (0x0400 - 0x0400);
        const int runMode_idx = (0x0401 - 0x0400);
        const int ctlMode_idx = (0x0402 - 0x0400);

        dev->started = (int)(tab_us[started_idx]);
        dev->runMode = (int)(tab_us[runMode_idx]);
        dev->ctlMode = (int)(tab_us[ctlMode_idx]);
        if (dev->runMode == 0)
        {
            sprintf(dev->sys_run_mode_set, "%s", "stop");
        }
        else if (dev->runMode == 1)
        {
            sprintf(dev->sys_run_mode_set, "%s", "loop");
        }
        else if (dev->runMode == 2)
        {
            sprintf(dev->sys_run_mode_set, "%s", "cool");
        }
        else if (dev->runMode == 3)
        {
            sprintf(dev->sys_run_mode_set, "%s", "heat");
        }
        else if (dev->runMode == 4)
        {
            sprintf(dev->sys_run_mode_set, "%s", "auto");
        }

        if (dev->ctlMode == 0)
        {
            sprintf(dev->ctrMode_str, "%s", "Cell temp");
        }
        else if (dev->ctlMode == 1)
        {
            sprintf(dev->ctrMode_str, "%s", "out temp");
        }
        else if (dev->ctlMode == 2)
        {
            sprintf(dev->ctrMode_str, "%s", "in temp");
        }
    }

    nb = 4;
    start = 0xA30B;
    chan_lock(chanidx);
    rc = chan_read_holdingregisters_with_retry(chanidx, addr, start, nb, tab_us);
    chan_unlock(chanidx);

    if (rc < 0)
    {
        comm_set_state(comm, COMMST_ERR);
        return;
    }
    else if (rc == 0)
    { /* read ok */
        dev->cellt_max = tab_us[0xA30B - start] / 10.0;
        dev->cellt_min = tab_us[0xA30C - start] / 10.0;
        dev->cellt_ave = tab_us[0xA30D - start] / 10.0;
        dev->cell_run = tab_us[0xA30E - start];
        if (dev->cell_run == 0)
        {
            sprintf(dev->cell_run_str, "%s", "not run");
        }
        else if (dev->cell_run == 1)
        {
            sprintf(dev->cell_run_str, "%s", "running");
        }
        else
        {
            sprintf(dev->cell_run_str, "%s", "unknown");
        }
    }
}

static void mc0051gs_comm_0xE600(int idx)
{
    unsigned short tab_us[128] = {0};
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int start, nb, rc, i;
    int ret = 0;

    if (comm_get_state(comm) != COMMST_NORMAL)
    {
        return;
    }

    // start = 0xE600;
    // chan_lock(chanidx);
    // usleep(100000);                                                        // 100ms
    // rc = chan_write_single_register_with_retry(chanidx, addr, start, 220); // 制冷点先默认22
    // chan_unlock(chanidx);
    // if (rc < 0)
    // {
    //     comm_set_state(comm, COMMST_ERR);
    //     return;
    // }

    // start = 0xE602;
    // chan_lock(chanidx);
    // usleep(100000);
    // rc = chan_write_single_register_with_retry(chanidx, addr, start, 50); // 制冷回差默认5
    // chan_unlock(chanidx);
    // if (rc < 0)
    // {
    //     comm_set_state(comm, COMMST_ERR);
    //     return;
    // }

    chan_lock(comm->chanidx);
    rc = chan_read_holdingregisters_with_retry(comm->chanidx, comm->adr, 0x0400, 1, tab_us);
    chan_unlock(comm->chanidx);
    if (rc < 0)
    {
        comm_set_state(comm, COMMST_ERR);
        return;
    }
    else
    {
        dev->started = tab_us[0];
    }

    nb = 19;
    start = 0xE600;
    chan_lock(chanidx);
    rc = chan_read_holdingregisters_with_retry(chanidx, addr, start, nb, tab_us);
    chan_unlock(chanidx);
    if (rc < 0)
    {
        comm_set_state(comm, COMMST_ERR);
        return;
    }
    else if (rc == 0)
    { /* read ok */
        dev->cool_temp = *((signed short *)&tab_us[0xE600 - start]) / 10.0;
        dev->heat_temp = *((signed short *)&tab_us[0xE601 - start]) / 10.0;
        dev->cool_gap_temp = tab_us[0xE602 - start] / 10.0;
        dev->heat_gap_temp = tab_us[0xE603 - start] / 10.0;
        dev->pump_gear = tab_us[0xE604 - start]; /*水泵档位*/
        dev->adr = tab_us[0xE605 - start];
        if (tab_us[0xE606 - start] == 2)
        {
            dev->baud = 4800;
        }
        else if (tab_us[0xE606 - start] == 3)
        {
            dev->baud = 9600;
        }
        else if (tab_us[0xE606 - start] == 4)
        {
            dev->baud = 19200;
        }
        else if (tab_us[0xE606 - start] == 5)
        {
            dev->baud = 38400;
        }
        else if (tab_us[0xE606 - start] == 6)
        {
            dev->baud = 57600;
        }
        else
        {
            dev->baud = 0;
        }

        dev->comp_gear = tab_us[0xE608 - start]; /*压缩机档位*/

        dev->cool_cell_temp = tab_us[0xE60C - start] / 10.0;      /*cell is working*/
        dev->cool_stop_cell_temp = tab_us[0xE60D - start] / 10.0; /*cell is working*/
        dev->heat_cell_temp = tab_us[0xE60E - start] / 10.0;      /*cell is working*/
        dev->heat_stop_cell_temp = tab_us[0xE60F - start] / 10.0; /*cell is working*/

        dev->cool_gap_cell_temp_noworking = tab_us[0xE610 - start] / 10.0; /*在电池非运行状态时，制冷开启温度= 电芯温度制冷点+ 电池非运行模式制冷偏差温度*/

        dev->cell_self_cycle_start_diff_temp = tab_us[0xE611 - start] / 10.0; /*电芯温度自循环启动差*/
        dev->cell_self_cycle_stop_diff_temp = tab_us[0xE612 - start] / 10.0;  /*电芯温度自循环启动差*/
    }
}

static void mc0051gs_comm_0xE700(int idx)
{
    unsigned short tab_us[128] = {0};
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    int chanidx = comm->chanidx;
    int addr = comm->adr;
    int start, nb, rc, i;
    int ret = 0;
    int temp = 0;

    if (comm_get_state(comm) != COMMST_NORMAL)
    {
        return;
    }

    nb = 72;
    start = 0xE700;
    chan_lock(chanidx);
    rc = chan_read_holdingregisters_with_retry(chanidx, addr, start, nb, tab_us);
    chan_unlock(chanidx);
    if (rc < 0)
    {
        comm_set_state(comm, COMMST_ERR);
        return;
    }
    else if (rc == 0)
    { /* read ok */

        dev->out_water_temp = tab_us[0xE700 - start] / 10.0;
        dev->in_water_temp = tab_us[0xE701 - start] / 10.0;
        dev->out_air_temp = tab_us[0xE702 - start] / 10.0;
        dev->ev_temp = tab_us[0xE703 - start] / 10.0;
        dev->in_water_press = tab_us[0xE704 - start] / 100.0;
        dev->out_water_press = tab_us[0xE705 - start] / 100.0;
        dev->out_water_high_temp_alarm = tab_us[0xE706 - start]; /*0 正常,1 告警,255告警未使能*/
        dev->out_water_low_temp_alarm = tab_us[0xE707 - start];  /*0 正常,1 告警,255告警未使能*/
        dev->out_temp_sensor_alarm = tab_us[0xE708 - start];     /*0 正常,1 告警,255告警未使能*/
        dev->in_temp_sensor_alarm = tab_us[0xE709 - start];      /*0 正常,1 告警,255告警未使能*/
        dev->pump_comm_alarm = tab_us[0xE70A - start];           /*0 正常,1 告警,255告警未使能*/
        dev->VFD_comm_alarm = tab_us[0xE70B - start];            /*0 正常,1 告警,255告警未使能*/
        dev->sys_high_voltage_lock = tab_us[0xE70C - start];     /*0 正常,1 锁定,255告警未使能*/
        dev->sys_low_voltage_lock = tab_us[0xE70D - start];      /*0 正常,1 锁定,255告警未使能*/
        dev->air_out_over_temp_lock = tab_us[0xE70E - start];    /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_oc_lock = tab_us[0xE70F - start];               /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_ot_lock = tab_us[0xE710 - start];               /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_over_fre_lock = tab_us[0xE711 - start];         /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_under_fre_lock = tab_us[0xE712 - start];        /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_phase_lost_lock = tab_us[0xE713 - start];       /*0 正常,1 锁定,255告警未使能*/
        dev->VFD_other_fault_lock = tab_us[0xE714 - start];      /*0 正常,1 锁定,255告警未使能*/
        dev->alarm_level = tab_us[0xE715 - start];
        if (dev->alarm_level == 0)
        {
            sprintf(dev->alarm_level_str, "%s", "no alarm");
        }
        else if (dev->alarm_level == 1)
        {
            sprintf(dev->alarm_level_str, "%s", "serious alarm");
        }
        else if (dev->alarm_level == 2)
        {
            sprintf(dev->alarm_level_str, "%s", "secondary alarm");
        }
        else if (dev->alarm_level == 3)
        {
            sprintf(dev->alarm_level_str, "%s", "commonly alarm");
        }
        else
        {
            sprintf(dev->alarm_level_str, "%s", "unkown alarm");
        }

        dev->elc_heat_state = tab_us[0xE716 - start];
        dev->lack_liquid_alarm = tab_us[0xE717 - start];          /*0 正常,1 告警,255告警未使能*/
        dev->sys_pree_high_alarm = tab_us[0xE718 - start];        /*0 正常,1 告警,255告警未使能*/
        dev->out_water_press_high_alarm = tab_us[0xE719 - start]; /*0 正常,1 告警,255告警未使能*/
        dev->pump_speed = tab_us[0xE71A - start] / 10.0;
        dev->pump_state = tab_us[0xE71B - start];
        dev->heart = tab_us[0xE71C - start];
        dev->comp_state = tab_us[0xE71D - start];

        temp = tab_us[0xE721 - start];
        temp = (temp << 16) + tab_us[0xE720 - start];
        dev->comp_run_time = temp;

        temp = tab_us[0xE723 - start];
        temp = (temp << 16) + tab_us[0xE722 - start];
        dev->comp_start_times = temp;

        temp = tab_us[0xE725 - start];
        temp = (temp << 16) + tab_us[0xE724 - start];
        dev->elc_heat_run_time = temp;

        temp = tab_us[0xE727 - start];
        temp = (temp << 16) + tab_us[0xE726 - start];
        dev->elc_heat_start_times = temp;

        temp = tab_us[0xE729 - start];
        temp = (temp << 16) + tab_us[0xE728 - start];
        dev->pump_run_time = temp;

        temp = tab_us[0xE72B - start];
        temp = (temp << 16) + tab_us[0xE72A - start];
        dev->pump_start_times = temp;

        temp = tab_us[0xE72D - start];
        temp = (temp << 16) + tab_us[0xE72C - start];
        dev->outfan_run_time = temp;

        temp = tab_us[0xE72F - start];
        temp = (temp << 16) + tab_us[0xE72E - start];
        dev->outfan_start_times = temp;

        dev->sys_run_state = tab_us[0xE730 - start];
        if (dev->sys_run_state == 0)
        {
            sprintf(dev->sys_run_state_str, "%s", "stop");
        }
        else if (dev->sys_run_state == 1)
        {
            sprintf(dev->sys_run_state_str, "%s", "Internal circulation");
        }
        else if (dev->sys_run_state == 2)
        {
            sprintf(dev->sys_run_state_str, "%s", "cooling");
        }
        else if (dev->sys_run_state == 3)
        {
            sprintf(dev->sys_run_state_str, "%s", "heating");
        }
        else
        {
        }

        dev->pump_fault = tab_us[0xE735 - start];
        dev->fan_drive_fault = tab_us[0xE736 - start];
        dev->fan_drive_comm_fault = tab_us[0xE737 - start];
        dev->upper_computer_comm_fault = tab_us[0xE738 - start];
        dev->cellt_max_comm_fault = tab_us[0xE739 - start];
        dev->cellt_min_comm_fault = tab_us[0xE740 - start];
        dev->cellt_ave_comm_fault = tab_us[0xE741 - start];
        dev->water_over_press = tab_us[0xE742 - start] / 10.0;
        dev->water_under_press = tab_us[0xE743 - start] / 10.0;
        dev->in_water_over_press_fault = tab_us[0xE744 - start];
        dev->in_water_under_press_fault = tab_us[0xE745 - start];
        dev->out_water_over_press_fault = tab_us[0xE746 - start];
        dev->out_water_under_press_fault = tab_us[0xE747 - start];
    }
    else
    {
        return;
    }
}

int mc0051gs_comm_init(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;

    comm_set_state(comm, COMMST_ERR);
}

int mc0051gs_comm_reset(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    comm_reset(comm);
    // comm_set_state( comm, COMMST_NORMAL );
}

int write_single_register(int idx, int regaddr, int value)
{
    int ret = 0;
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;

    chan_lock(comm->chanidx);
    ret = chan_write_single_register_with_retry(comm->chanidx, comm->adr, regaddr, value);
    chan_unlock(comm->chanidx);
    // log_dbg("%s, idx:%d, val:%d, ret:%d", __func__, idx, value, ret);
    return ret;
}

int mc0051gs_set_dev_start(int idx)
{
    return write_single_register(idx, 0x0400, 1);
}

int mc0051gs_set_dev_stop(int idx)
{
    return write_single_register(idx, 0x0400, 0);
}

int mc0051gs_set_dev_mbadr(int idx, int val)
{
    return write_single_register(idx, 0x0007, val);
}

int mc0051gs_set_run_mode(int idx, int mode)
{
    return write_single_register(idx, 0x0401, mode);
}

int mc0051gs_set_ctl_mode(int idx, int mode)
{
    if (mode == 0) // 电芯温度控制
    {
        mc0051gs_set_cool_start_temp_cellmode(idx, 25);
        mc0051gs_set_cool_stop_temp_cellmode(idx, 21);
        mc0051gs_set_heat_start_temp_cellmode(idx, 15);
        mc0051gs_set_heat_stop_temp_cellmode(idx, 24);
    }
    else if (mode == 1 || mode == 2)
    {
        static double cool_set = 22, hot_set = 20;
        if (pack_get_cell_t_max() >= 25 && pack_get_cell_t_min() >= 22)
        {
            cool_set = mc0051gs[1].out_water_temp - 4;
            log_dbg("cool_set:%f", cool_set);
        }
        else if (pack_get_cell_t_min() <= 20 && pack_get_cell_t_max() <= 22)
        {
            hot_set = mc0051gs[1].out_water_temp + 6;
            log_dbg("hot_set:%f", hot_set);
        }
        else
        {
            cool_set = 22;
            hot_set = 20;
            log_dbg("hot_set:%f, cool_set:%f", hot_set, cool_set);
        }
        if (cool_set < hot_set)
        {
            hot_set = cool_set - 2;
        }
        mc0051gs_set_cool_temp(idx, cool_set);
        mc0051gs_set_cool_gap_temp(idx, 2);
        mc0051gs_set_heat_temp(idx, hot_set);
        mc0051gs_set_heat_gap_temp(idx, 2);
    }
    else
    {
        return -1;
    }
    return write_single_register(idx, 0x0402, mode);
}

int mc0051gs_set_cellt_max(int idx, double temp)
{
    return write_single_register(idx, 0xA30B, (int)(temp * 10));
}

int mc0051gs_set_cellt_min(int idx, double temp)
{
    return write_single_register(idx, 0xA30C, (int)(temp * 10));
}

int mc0051gs_set_cellt_avg(int idx, double temp)
{
    return write_single_register(idx, 0xA30D, (int)(temp * 10));
}

int mc0051gs_set_cellt_running(int idx, int working)
{
    return write_single_register(idx, 0xA30E, working);
}

int mc0051gs_set_cool_temp(int idx, int val)
{
    return write_single_register(idx, 0xE600, val * 10);
}
int mc0051gs_set_heat_temp(int idx, int val)
{
    return write_single_register(idx, 0xE601, val * 10);
}
int mc0051gs_set_cool_gap_temp(int idx, int val)
{
    return write_single_register(idx, 0xE602, val * 10);
}
int mc0051gs_set_heat_gap_temp(int idx, int val)
{
    return write_single_register(idx, 0xE603, val * 10);
}
int mc0051gs_set_pump_gear(int idx, int val)
{
    return write_single_register(idx, 0xE604, val * 10);
}
int mc0051gs_set_comp_gear(int idx, int val)
{
    return write_single_register(idx, 0xE608, val);
}

int mc0051gs_set_cool_start_temp_cellmode(int idx, int val)
{
    return write_single_register(idx, 0xE60C, val * 10);
}
int mc0051gs_set_cool_stop_temp_cellmode(int idx, int val)
{
    return write_single_register(idx, 0xE60D, val * 10);
}
int mc0051gs_set_heat_start_temp_cellmode(int idx, int val)
{
    return write_single_register(idx, 0xE60E, val * 10);
}
int mc0051gs_set_heat_stop_temp_cellmode(int idx, int val)
{
    return write_single_register(idx, 0xE60F, val * 10);
}

void mc0051gs_comm_dac(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    int ret = 0;

    if (comm_get_state(comm) != COMMST_NORMAL)
    {
        return;
    }

    comm_start_cal_dac_timing(comm);

    if (comm_get_dac_param_en(comm) == 1)
    {
        comm_set_dac_param_en(comm, 0);
        mc0051gs_set_run_mode(idx, 4); // 自动
    }

    // 设定空调运行模式和温度控制模式
    mc0051gs_set_ctl_mode(idx, 1); // 电芯温度控制

    mc0051gs_comm_0xA30B(idx);
    mc0051gs_comm_0xE600(idx);
    mc0051gs_comm_0xE700(idx);

    comm_stop_cal_dac_timing(comm);
}