#include "mc0051gs.h"
#include "mc0051gs_comm.h"
#include "mc0051gs_sm.h"
#include "plt.h"

int mc0051gs_nbr;
struct mc0051gs_t mc0051gs[MC0051GS_NBR_MAX + 1];

int mc0051gs_send_sm_cmd(int idx, int cmd)
{
    int ret = 0;
    struct mc0051gs_t *dev = &mc0051gs[idx];
    dev->cmd = cmd;
    log_dbg("%s, idx:%d, cmd:%d, ret:%d", __func__, idx, cmd, ret);
    return ret;
}

int mc0051gs_send_sm_cmd_all(int cmd)
{
    int ret = 0;
    int idx;
    struct mc0051gs_t *dev = NULL;
    for (idx = 1; idx <= mc0051gs_nbr; idx++)
    {
        mc0051gs_send_sm_cmd(idx, cmd);
    }
    return ret;
}

int mc0051gs_chk_state_all(int stat)
{
    int idx;
    for (idx = 1; idx <= mc0051gs_nbr; idx++)
    {
        if (mc0051gs_get_state(idx) != stat)
        {
            return -1;
        }
    }
    return 0;
}

int mc0051gs_get_cmd(int idx)
{
    return mc0051gs[idx].cmd;
}

void mc0051gs_reset_cmd(int idx)
{
    mc0051gs[idx].cmd = CMD_SM_DONE;
}

int mc0051gs_get_state(int idx)
{
    return mc0051gs[idx].sm.state;
}

int mc0051gs_aux(int idx)
{
    static int cnt = 0;
    if (cnt < mc0051gs_nbr && mqtt_get_state() == SMST_READY)
    {
        if (idx == mc0051gs_nbr)
        {
            cloud.ac_init = 0;
        }
        char buf[4096] = {0};
        mc0051gs_get_init_data(ctn_get_idx_in_ess(), idx, buf);
        cloud_send_init(buf);
        cnt++;
    }
}

static void *mc0051gs_thrd_main(void *param)
{
    struct mc0051gs_t *dev = NULL;
    int idx;

    log_dbg("%s, ++", __func__);

    for (idx = 1; idx <= mc0051gs_nbr; idx++)
    {
        mc0051gs_sm_init(idx);
        mc0051gs_comm_init(idx);
        mc0051gs_aux(idx);
    }

    while (1)
    {
        for (idx = 1; idx <= mc0051gs_nbr; idx++)
        {
            mc0051gs_comm_dac(idx);
            mc0051gs_sm(idx);
            // usleep(1000000); /* 100ms */
            sleep(1);
        }
    }

    log_dbg("%s, --, idx:%d", __func__, idx);
}

static int mc0051gs_dbcb(void *para, int ncolumn, char **columnvalue, char *columnname[])
{
    int i;
    struct dbcbparam_t *pcbparam = (struct dbcbparam_t *)para;
    struct mc0051gs_t *pdev;
    int idx = 0;

    pcbparam->nrow++;
    log_dbg("%s, ++, row:%d, col:%d", __func__, pcbparam->nrow, ncolumn);

    pdev = &mc0051gs[pcbparam->nrow];
    for (i = 0; i < ncolumn; i++)
    {
        if (strcmp("chan_idx", columnname[i]) == 0)
        {
            pdev->comm.chanidx = atoi(columnvalue[i]);
        }
        else if (strcmp("info", columnname[i]) == 0)
        {
            strcpy(pdev->szinfo, columnvalue[i]);
        }
        else if (strcmp("adr", columnname[i]) == 0)
        {
            pdev->comm.adr = atoi(columnvalue[i]);
        }
        else if (strcmp("idx", columnname[i]) == 0)
        {
            pdev->idx = atoi(columnvalue[i]);
        }
        else if (strcmp("devid", columnname[i]) == 0)
        {
            if (columnvalue[i] != NULL && strcmp(columnvalue[i], "") != 0)
            {
                strcpy(pdev->szdev_id, columnvalue[i]);
            }
            else
            {
                log_dbg("%s, devid is null", __func__);
            }
        }
    }

    pcbparam->ret = 0;
    log_dbg("%s, --,ret:%d", __func__, pcbparam->ret);
    return 0;
}

int mc0051gs_init(void)
{
    pthread_t thrd;
    int result = 0;
    int ret = 0;
    int idx = 0;
    struct mc0051gs_t *dev = NULL;
    char *errmsg = NULL;
    char sql[1024];
    struct dbcbparam_t cbparam;
    sqlite3 *db = STA.cfg_db;

    log_dbg("%s, ++", __func__);

    plt_lock_ctndb();
    sprintf(sql, "select * from mc0051gs");
    cbparam.nrow = 0;
    result = sqlite3_exec(db, sql, mc0051gs_dbcb, (void *)&cbparam, &errmsg);
    plt_unlock_ctndb();
    if (result != SQLITE_OK)
    {
        log_dbg("%s, result != SQLITE_OK : %d", __func__, result);
        ret = -1;
    }
    else if (cbparam.ret != 0)
    {
        log_dbg("%s, cbparam.ret != 0 : %d", __func__, cbparam.ret);
        ret = -2;
    }
    else
    {
        mc0051gs_nbr = cbparam.nrow;
        cbparam.nrow = 0;
        db = plt_get_devdb();
        plt_lock_devdb();
        sprintf(sql, "select * from mc0051gs");
        result = sqlite3_exec(db, sql, mc0051gs_dbcb, (void *)&cbparam, &errmsg);
        plt_unlock_devdb();

        for (int i = 1; i <= mc0051gs_nbr; ++i)
        {
            if (strcmp(mc0051gs[i].szdev_id, "") == 0)
            {
                if (get_snow_id(mc0051gs[i].szdev_id) != 0)
                {
                    ret = -4;
                }
                else
                {
                    char sql[1024];
                    char *errmsg = NULL;
                    sprintf(sql, "update mc0051gs set devid=\"%s\" where idx=%d", mc0051gs[i].szdev_id, mc0051gs[i].idx);
                    plt_lock_devdb();
                    int rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
                    plt_unlock_devdb();
                    if (rc != SQLITE_OK)
                    {
                        log_dbg("%s, failed to update level device id:%s", __func__, errmsg);
                        ret = -4;
                        goto leave;
                    }
                    else
                    {
                        log_dbg("%s, update device id:%s", __func__, mc0051gs[i].szdev_id);
                    }
                }
            }
        }

        if (pthread_create(&thrd, NULL, mc0051gs_thrd_main, NULL) != 0)
        {
            ret = -1;
            log_dbg("%s, create mc0051gs thrd main fail", __func__);
        }
    }
leave:
    log_dbg("%s--, ret:%d", __func__, ret);
    return ret;
}

int mc0051gs_get_addr(int idx)
{
    return mc0051gs[idx].comm.adr;
}

int mc0051gs_get_comm_st(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    return comm_get_state(comm);
}

int mc0051gs_get_chan_idx(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    return comm_get_chan_idx(comm);
}

char *mc0051gs_get_comm_st_str(int idx)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct comm_t *comm = &dev->comm;
    return comm_get_state_str(comm);
}

int mc0051gs_get_tick(int idx)
{
    return mc0051gs[idx].sm.tick;
}

int mc0051gs_get_nbr()
{
    return mc0051gs_nbr;
}

int mc0051gs_get_tool_data(int idx, char *buf)
{
    if (idx < 1 || idx > mc0051gs_nbr || buf == NULL)
        return -1;
    struct mc0051gs_t *dev = &mc0051gs[idx];
    struct statemachine_t *sm = &dev->sm;
    struct comm_t *comm = &dev->comm;
    char buf_temp[1024];

    sm_get_summary(sm, buf_temp, sizeof(buf_temp));
    sprintf(buf, " [%d] %s ", idx, buf_temp);

    comm_get_summary(comm, buf_temp, sizeof(buf_temp));
    strcat(buf, buf_temp);

    sprintf(buf_temp, "\ndev id:%s sys_started: " GREEN "%d" NONE ",mode set: " GREEN " %s " NONE ",sys_run_state:" YELLOW "%s" NONE ",alarm_level:" YELLOW "%s" NONE ",elc_heat_state:%d,pump_state:%d,comp_state:%d,"
                      "in_water_temp:" YELLOW "%.1f" NONE ",out_water_temp:" YELLOW "%.1f" NONE ",out_air_temp:" YELLOW "%.1f" NONE ",ev_temp:" YELLOW "%.1f" NONE ",in_water_press:" YELLOW "%.1f" NONE ","
                      "out_water_press:" YELLOW "%.1f" NONE ",pump_speed:" YELLOW "%.1f" NONE "\n",
            dev->szdev_id,
            dev->started,
            dev->sys_run_mode_set,
            dev->sys_run_state_str, dev->alarm_level_str, dev->elc_heat_state, dev->pump_state, dev->comp_state,
            dev->in_water_temp, dev->out_water_temp, dev->out_air_temp, dev->ev_temp, dev->in_water_press,
            dev->out_water_press, dev->pump_speed);
    strcat(buf, buf_temp);

    sprintf(buf_temp, "cool_temp:%.1f,heat_temp:%.1f,cool_gap_temp:%.1f,heat_gap_temp:%.1f,pump_gear:%d,"
                    "comp_gear:%d,cool_cell_temp:%.1f,cool_stop_cell_temp:%.1f,heat_cell_temp:%.1f,heat_stop_cell_temp:%.1f,"
                    "cool_gap_cell_temp_noworking:%.1f,cell_self_cycle_start_diff_temp:%.1f,cell_self_cycle_stop_diff_temp:%.1f\n",
            dev->cool_temp, dev->heat_temp, dev->cool_gap_temp, dev->heat_gap_temp, dev->pump_gear,
            dev->comp_gear, dev->cool_cell_temp, dev->cool_stop_cell_temp, dev->heat_cell_temp, dev->heat_stop_cell_temp,
            dev->cool_gap_cell_temp_noworking, dev->cell_self_cycle_start_diff_temp, dev->cell_self_cycle_stop_diff_temp);
    strcat(buf, buf_temp);

    sprintf(buf_temp, "cellt_max:%.1f,cellt_min:%.1f,cellt_ave:%.1f,cell_run:%s\n",
            dev->cellt_max, dev->cellt_min, dev->cellt_ave, dev->cell_run_str);
    strcat(buf, buf_temp);

    // alarm
    sprintf(buf_temp, "out_water_high_temp_alarm:%d,out_water_low_temp_alarm:%d,out_temp_sensor_alarm:%d,in_temp_sensor_alarm:%d,pump_comm_alarm:%d,\
VFD_comm_alarm:%d,sys_high_voltage_lock:%d,sys_low_voltage_lock:%d,air_out_over_temp_lock:%d,VFD_oc_lock:%d,\
VFD_ot_lock:%d,VFD_over_fre_lock:%d,VFD_under_fre_lock:%d,VFD_phase_lost_lock:%d,VFD_other_fault_lock:%d,\
lack_liquid_alarm:%d,sys_pree_high_alarm:%d,out_water_press_high_alarm:%d,pump_fault:%d,fan_drive_fault:%d,\
fan_drive_comm_fault:%d,upper_computer_comm_fault:%d,cellt_max_comm_fault:%d,cellt_min_comm_fault:%d,cellt_ave_comm_fault:%d,\
water_over_press:%d,water_under_press:%d,in_water_over_press_fault:%d,in_water_under_press_fault:%d,out_water_over_press_fault:%d,\
out_water_under_press_fault:%d\n",
            dev->out_water_high_temp_alarm, dev->out_water_low_temp_alarm, dev->out_temp_sensor_alarm, dev->in_temp_sensor_alarm, dev->pump_comm_alarm,
            dev->VFD_comm_alarm, dev->sys_high_voltage_lock, dev->sys_low_voltage_lock, dev->air_out_over_temp_lock, dev->VFD_oc_lock,
            dev->VFD_ot_lock, dev->VFD_over_fre_lock, dev->VFD_under_fre_lock, dev->VFD_phase_lost_lock, dev->VFD_other_fault_lock,
            dev->lack_liquid_alarm, dev->sys_pree_high_alarm, dev->out_water_press_high_alarm, dev->pump_fault, dev->fan_drive_fault,
            dev->fan_drive_comm_fault, dev->upper_computer_comm_fault, dev->cellt_max_comm_fault, dev->cellt_min_comm_fault, dev->cellt_ave_comm_fault,
            dev->water_over_press, dev->water_under_press, dev->in_water_over_press_fault, dev->in_water_under_press_fault, dev->out_water_over_press_fault,
            dev->out_water_under_press_fault);
    strcat(buf, buf_temp);
    return 0;
}

int mc0051gs_get_tbmqtt_data(int idx, char *buf)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    sprintf(buf, "'ac%d_state':'%s', 'ac%d_rtnwater_pre':%.1f,'ac%d_outwater_pre':%.1f,'ac%d_rtnwater_t':%.1f,'ac%d_outwater_t':%.1f,'ac%d_outside_t':%.1f, 'ac%d_start':%d",
            idx, dev->sm.szState,
            idx, dev->in_water_press,
            idx, dev->out_water_press,
            idx, dev->in_water_temp,
            idx, dev->out_water_temp,
            idx, dev->ev_temp,
            idx, dev->started);
}

int mc0051gs_get_cloud_data(int ctn_idx, int idx, char *buf)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];

    sprintf(buf, "{\"device_id\":\"%s\", \"type\":4, \"rtnwater_pre\":%.1f,\"outwater_pre\":%.1f,\"rtnwater_t\":%.1f,\"outwater_t\":%.1f,\"outside_t\":%.1f,\"state\":\"%d\"}",
            dev->szdev_id,
            dev->in_water_press,
            dev->out_water_press,
            dev->in_water_temp,
            dev->out_water_temp,
            dev->ev_temp,
            dev->sm.state);

    return 0;
}

int mc0051gs_get_init_data(int ctn_idx, int idx, char *buf)
{
    sprintf(buf, "{\"device_id\":\"%s\", \"type\":4, \"idx\":%d, \"pid\":\"%s\", \"config\":{ \
    \"chan_idx\":%d, \"adr\":%d}}",
            mc0051gs[idx].szdev_id,
            idx,
            ctn_get_dev_id(),
            mc0051gs[idx].comm.chanidx,
            mc0051gs[idx].comm.adr);
    return 0;
}

int mc0051gs_get_modbus_data(int idx, unsigned short *data)
{
    struct mc0051gs_t *dev = &mc0051gs[idx];
    data[0] = (unsigned short)DEVM_MC90HDNC1A;
    data[1] = (unsigned short)1;
    data[2] = (unsigned short)dev->sm.state;
    data[3] = (unsigned short)dev->sm.step;
    data[4] = (unsigned short)dev->sm.err;
    data[5] = (unsigned short)dev->comm.adr;
    data[6] = (unsigned short)dev->comm.state;
    data[7] = (unsigned short)dev->runMode;
    data[8] = (unsigned short)dev->ctlMode;
    data[9] = (unsigned short)dev->cool_temp*10;
    data[10] = (unsigned short)dev->heat_temp*10;
    data[11] = (unsigned short)dev->cool_gap_temp*10;
    data[12] = (unsigned short)dev->heat_gap_temp*10;
    data[13] = (unsigned short)dev->pump_gear;
    data[14] = (unsigned short)dev->comp_gear;
    data[15] = (unsigned short)dev->out_water_temp*10;
    data[16] = (unsigned short)dev->in_water_temp*10;
    data[17] = (unsigned short)dev->out_water_press*100;
    data[18] = (unsigned short)dev->in_water_press*100;
    data[19] = (unsigned short)dev->pump_speed*10;
    return 0;
}