#include "device.h"
#include "config/board_config.h"

uint8_t device_init(device_t *port)
{
    uint8_t res = DEVICE_OK;
#if UART_ENABLE
    res = uart_init(&port->init_device);
    if(res)
    {
        SYS_LOG_WRN("device start uart error");
        return DEVICE_UART_ERROR;
    }
#endif
#if BLE_ENABLE
    res = ble_init(&port->init_device);
    if(res)
    {
        SYS_LOG_WRN("ble init error");
        return DEVICE_BLE_ERROR;
    }
#endif
#if WIFI_ENABLE
    res = wifi_init(&port->init_device);
    if(res)
    {
        SYS_LOG_WRN("wifi init error");
        return DEVICE_WIFI_ERROR;
    }
#endif
    //默认选择串口
    res = embedded_device_choice(port, DATA_PORT_TYPE_UART);
    if(res == DEVICE_EMBEDDED_ERROR)
    {
        SYS_LOG_ERR("embedded device choice error");
    }
    //默认蓝牙 val
    res = pc_device_choice(port, DATA_PORT_TYPE_BLE_VAL);
    if(res == DEVICE_PC_ERROR)
    {
        SYS_LOG_ERR("pc device choice error");
    }
    return DEVICE_OK;
}
uint8_t uart_init(init_device_t *port)
{
    // port->uart_port = sb_uart_port_bind(g_cfg_board->uart_fc.id, g_cfg_board->uart_fc.br, g_cfg_board->uart_fc.pin_txd.pin, g_cfg_board->uart_fc.pin_rxd.pin, g_cfg_board->uart_fc.irq_prior, 1024, 0, NULL);
    port->uart_port = sb_uart_port_bind(1, 115200, 0, 10, 21, 1024, 0, NULL);

    if(port->uart_port == NULL)
    {
        SYS_LOG_WRN("uart init error");
        return 1;
    }
    if(sb_data_port_start(port->uart_port))
    {
        SYS_LOG_WRN("uart start error");
        return 1;
    }
    return DEVICE_OK;
}

static void _sb_manufacturer_encode(uint8_t manufacturer_data[20])
{
    for (int i = 0; i < 20; i++)
    {
        manufacturer_data[i] = i + 1;
    }
}
uint8_t ble_init(init_device_t *port)
{
    ble_server_init_t ble_init_param = {
        .device_name = "Sertorf",                // 设备名
        .manufacturer_data = _sb_manufacturer_encode, // 回调函数，生成 manufacturer[20]
        .connect_cb = NULL,                           // 回调函数， NULL 值可用
    };
    //初始化参数
    sb_ble_server_port_init(&ble_init_param);

    port->ble_spp_server_cmd = ble_server_port_bind_cmd(0x2000, NULL);
    port->ble_spp_server_val = ble_server_port_bind_val(0x400, NULL);

    if(port->ble_spp_server_cmd == NULL || port->ble_spp_server_val == NULL)
    {
        SYS_LOG_WRN("ble init error");
        return 1;
    }
    if(sb_data_port_start(port->ble_spp_server_cmd))
    {
        SYS_LOG_WRN("ble cmd start error");
        return 1;
    }
    if(sb_data_port_start(port->ble_spp_server_val))
    {
        SYS_LOG_WRN("ble val start error");
        return 1;
    }

    return DEVICE_OK;
}

uint8_t wifi_init(init_device_t *port)
{
    return DEVICE_OK;
}

uint8_t embedded_device_choice(device_t *port, uint8_t type)
{
    //端口与PC一致
    if(port->pc_device_type == type)
    {
        SYS_LOG_WRN("pc Port consistency");
        return DEVICE_WRN_EMBEDDED_TYPE;
    }
    
    port->embedded_device_type = type;
    switch (port->embedded_device_type)
    {
        case DATA_PORT_TYPE_UART:
            port->embedded_device = port->init_device.uart_port;
            break;
        case DATA_PORT_TYPE_WIFI:
            port->embedded_device = port->init_device.wifi;
            break;
        case DATA_PORT_TYPE_BLE_CMD:
            port->embedded_device = port->init_device.ble_spp_server_cmd;
            break;
        case DATA_PORT_TYPE_BLE_VAL:
            port->embedded_device = port->init_device.ble_spp_server_val;
            break;
        default:
            break;
    }

    if(port->embedded_device == NULL)
    {
        SYS_LOG_WRN("embedded device choice error");
        return DEVICE_EMBEDDED_ERROR;
    }

    return DEVICE_OK;
}

int embedded_device_read(device_t *port, void *buffer, uint32_t length)
{
    return sb_data_port_read(port->embedded_device, buffer, length, 0);
}

int embedded_device_write(device_t *port, void *buffer, uint32_t length)
{
    return sb_data_port_write(port->embedded_device, buffer, length, 0);
}
uint32_t embedded_device_get_rx_length(device_t *port)
{
    return sb_data_port_get_rx_length(port->embedded_device);
}

uint8_t pc_device_choice(device_t *port, uint8_t type)
{
    //端口与embedded一致
    if(port->embedded_device_type == type)
    {
        SYS_LOG_WRN("embedded Port consistency");
        return DEVICE_WRN_PC_TYPE;
    }
    
    port->pc_device_type = type;
    switch (port->pc_device_type)
    {
        case DATA_PORT_TYPE_UART:
            port->pc_device = port->init_device.uart_port;
            break;
        case DATA_PORT_TYPE_WIFI:
            port->pc_device = port->init_device.wifi;
            break;
        case DATA_PORT_TYPE_BLE_CMD:
            port->pc_device = port->init_device.ble_spp_server_cmd;
            break;
        case DATA_PORT_TYPE_BLE_VAL:
            port->pc_device = port->init_device.ble_spp_server_val;
            break;
        default:
            break;
    }

    if(port->pc_device == NULL)
    {
        SYS_LOG_WRN("embedded device choice error");
        return DEVICE_PC_ERROR;
    }

    return DEVICE_OK;
}

int pc_device_read(device_t *port, void *buffer, uint32_t length)
{
    return sb_data_port_read(port->pc_device, buffer, length, 0);
}

int pc_device_write(device_t *port, void *buffer, uint32_t length)
{
    return sb_data_port_write(port->pc_device, buffer, length, 0);
}
uint32_t pc_device_get_rx_length(device_t *port)
{
    return sb_data_port_get_rx_length(port->pc_device);
}