#include "modbus.h"
#include "crcLib.h"
#include "gd32e23x.h"
#include "string.h"
// #include "systick.h"
#include "util.h"
#include <stdlib.h>

#include "modbus.h"

#include <string.h>
#include "FreeRTOS.h"
#include "task.h"

static modbus_slave_t slave;
//static modbus_master_t master;
static uint8_t modbus_mode = 0;

int8_t modbus_slave_init(uint8_t address)
{
    slave.address = address;
    slave.max_length = MODBUS_SLAVE_REG_MAX;
    slave.length = 0;
    slave.send_buffer_len = 0;
    memset(&(slave.send_buffer), 0, MODBUS_SLAVE_SEND_BUFF_LEX);
	slave.cmd_len = 0;
    return 0;
}

modbus_slave_t *modbus_slave_get(void)
{
    return &slave;
}

int8_t modbus_slave_add_reg(uint16_t address, uint16_t data, uint8_t access, modbus_reg_read_cb_t read_cb, modbus_reg_write_cb_t write_cb)
{
    if (slave.length < slave.max_length)
    {
        modbus_reg_t *reg = &(slave.regs[slave.length]);
        reg->address = address;
        reg->data = data;
        reg->access = access;
        reg->write_cb = write_cb;
        reg->read_cb = read_cb;
        slave.length++;
        return 0;
    }
    else
    {
        return -1;
    }
}

modbus_reg_t *modbus_slave_get_reg(uint16_t address)
{
    for (int i = 0; i < slave.length; i++)
    {
        if (slave.regs[i].address == address)
        {
            return &slave.regs[i];
        }
    }
    return NULL;
}

int8_t modbus_slave_reg_read_raw(uint16_t address, uint16_t *data)
{
    modbus_reg_t *reg = modbus_slave_get_reg(address);
    if (reg != NULL)
    {
        *data = reg->data;
        return 0;
    }
    else
    {
        return -1;
    }
}

int8_t modbus_slave_reg_write_raw(uint16_t address, uint16_t data)
{
	modbus_reg_t *reg = modbus_slave_get_reg(address);
    if (reg != NULL)
    {
        reg->data = data;
        return 0;
    }
    else
    {
        return -1;
    }
}

int8_t modbus_slave_reg_read(uint16_t address, uint16_t *data)
{
    modbus_reg_t *reg = modbus_slave_get_reg(address);
    if (reg != NULL)
    {
        if (reg->access == 1)
        {
            return -2;
        }
        if (reg->read_cb != NULL)
        {
            reg->data = reg->read_cb(address);
        }
        *data = reg->data;
        return 0;
    }
    else
    {
        return -1;
    }
}

int8_t modbus_slave_reg_write(uint16_t address, uint16_t data)
{
    modbus_reg_t *reg = modbus_slave_get_reg(address);
    if (reg != NULL)
    {
        if (reg->access == 0)
        {
            return -2;
        }
        reg->data = data;
        if (reg->write_cb != NULL)
        {
            reg->write_cb(address, reg->data);
        }
        return 0;
    }
    else
    {
        return -1;
    }
}

int8_t modbus_slave_reg_read_mult(uint16_t address, uint16_t reg_num, uint16_t *data)
{
    for (int i = 0; i < reg_num; i++)
    {
        if (modbus_slave_reg_read(address + i, data + i) != 0)
        {
            return -1;
        }
    }
    return 0;
}

int8_t modbus_slave_reg_write_mult(uint16_t address, uint16_t reg_num, uint16_t *data)
{
    for (int i = 0; i < reg_num; i++)
    {
        if (modbus_slave_reg_write(address + i, data[i]) != 0)
        {
            return -1;
        }
    }
    return 0;
}

int8_t modbus_slave_cmd_add(uint8_t cmd, modbus_slave_cmd_cb_t cmd_cb)
{
	if (slave.cmd_len < MODBUS_SLAVE_CMD_MAX)
    {
        modbus_cmd_t *box = &(slave.cmds[slave.cmd_len]);
        box->cmd = cmd;
		box->cb = cmd_cb;
        slave.cmd_len++;
        return 0;
    }
    else
    {
        return -1;
    }
}

modbus_cmd_t* modbus_slave_cmd_get(uint8_t cmd)
{
	for (int i = 0; i < slave.cmd_len; i++)
    {
        if (slave.cmds[i].cmd == cmd)
        {
            return &slave.cmds[i];
        }
    }
    return NULL;
}

//void modbus_master_init(uint16_t timeout, modbus_master_reg_cb_t reg_cb)
//{
//    master.state = 0;
//    master.timeout = timeout;
//    master.timeout_counter = 0;
//    master.address = 0;
//    master.function = 0;
//    master.error = 0;
//    master.error_code = 0;
//    master.data_length = 0;
//    master.reg_cb = reg_cb;
//  memset(master.data, 0, 256);
//}

//modbus_master_t *modbus_master_get(void)
//{
//    return &master;
//}

//int8_t modbus_master_wait_for_response(void)
//{
//    if (master.state != 3)
//    {
//        master.timeout_counter += MODBUS_MASTER_SLEEP_TIME;
//        if (master.timeout_counter >= master.timeout)
//        {
//	    master.timeout_counter = 0;
//            master.state = 0;
//            master.error = 1;
//            master.error_code = 0;
//            if (master.reg_cb != NULL)
//            {
//                master.reg_cb(master.address, master.error, master.error_code);
//            }
//            return -1;
//        }
//        else
//        {
//            vTaskDelay(pdMS_TO_TICKS(MODBUS_MASTER_SLEEP_TIME));
//        }
//    }

//    master.state = 0;
//    if (master.reg_cb != NULL)
//    {
//        master.reg_cb(master.address, master.error, master.error_code);
//    }
//    return 0;
//}



void modbus_set_mode(uint8_t mode)
{
    modbus_mode = mode;
}

uint8_t modbus_get_mode(void)
{
    return modbus_mode;
}