#include "IS3.h"
#define IS3_usart_port 1
#define IS3_TX 42
#define IS3_RX 41
#define IS3_RST 17

IS3::IS3()
{
    a1 = 0.0;
    a2 = 0.0;
    a3 = 0.0;
    a4 = 0.0;
}

void  IS3::init()
{
    Serial1.setRxBufferSize(1024*2);
    Serial1.setTimeout(10);
    Serial1.setTxBufferSize(1024*2);
    Serial1.begin(921600, SERIAL_8N1, IS3_RX, IS3_TX);
    
    // Serial1.onReceive(onUart1Data, true); // 建议用 true
    pinMode(IS3_RST,OUTPUT);
    on();
    IS3::reset();
    // IS3::reset();
    // vTaskDelay(1000);

    IS3::integration_time = 12;
    bool success = false;
    String is3_info;
    double aa1, aa2, aa3, aa4;
    uint32_t is3_bandnum;

    do
    {
        // Serial0.println("IS3 set_shutter_time");
        success = IS3::set_shutter_time(IS3::integration_time);
        vTaskDelay(10);
    } while (!success);
    // Serial0.printf("set_shutter_time : %d\n",)
    do
    {
        // Serial0.println("IS3 get_is3_info");
        success = IS3::get_is3_info(&is3_info);
        vTaskDelay(10);
    } while (!success);
    // Serial0.printf("IS3_info %s\n", is3_info.c_str());
    do
    {
        // Serial0.println("IS3 get_bochangxishu");
        success = IS3::get_bochangxishu(&aa1, &aa2, &aa3, &aa4);
        vTaskDelay(10);
    } while (!success);
    // Serial0.printf("aa1:%f aa2:%f aa3:%f aa4:%f\n",aa1,aa2,aa3,aa4);
    do
    {
        // Serial0.println("IS3 get_bandnum");
        success = IS3::get_bandnum(&is3_bandnum);
        vTaskDelay(10);
    } while (!success);
    // Serial0.printf("is3_bandnum:%d\n",is3_bandnum);
}

void IS3::reset()
{
    digitalWrite(IS3_RST,LOW);
    vTaskDelay(200);
    digitalWrite(IS3_RST,HIGH);
    vTaskDelay(1000);
}



void IS3::on()
{
    digitalWrite(IS3_RST,HIGH);
}

void IS3::off()
{
    digitalWrite(IS3_RST,LOW);
}

void IS3::write(uint8_t command,uint8_t *pData, uint16_t Size)
{
    uart_flush_input(IS3_usart_port);
    uint8_t send_buff[200];
    uint32_t send_lenth;

    send_lenth = IRIS_Protocol_Pack(command,Size,pData,send_buff);
    Serial1.write(send_buff,send_lenth);
}

// int IS3::read1(uint8_t *data_type,uint8_t *read_buf) 
// {

//     unsigned char command_data[1024 * 2];
//     uint16_t  data_length = 0;
//     // int a  = 200;
//     int a  = is3.integration_time * 3;
//     while (a--)
//     {
//         while(Serial1.available()) 
//         {
//             data_length += Serial1.readBytes(&command_data[data_length],1024*2);
//             a = 2;
//         }
//         // if(a< 10) a--;
//         vTaskDelay(1);
//     }
//     if (data_length <= 0)     
//     {
//         return -1;
//     }

//     data_length = IRIS_Cut_Befor_Header(command_data, data_length);
//     int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,data_type,read_buf);
//     if (ret < 0)    
//     {
//         return -1;
//     }

//     return ret;

// }


uint32_t  my_usart_available(uart_port_t uart_port)
{

    size_t available = 0;
    uart_get_buffered_data_len(uart_port, &available);
    // Serial0.printf("available:%d\n",available);
    return available;
    // if (uart->has_peek) available++;
}


int IS3::read(uint8_t *data_type,uint8_t *read_buf) 
{
    IS3::read_sta = 1;
    unsigned char command_data[1024 * 2];
    uint16_t  data_length = 0;
    // int a  = 200;
    int a  = is3.integration_time * 3 + 50;
    while (a--)
    {
        // while(Serial1.available())
        // uint32_t len =0;
        
        // uart_get_buffered_data_len(IS3_usart_port,&len);
        while(my_usart_available(IS3_usart_port))
        {
            // data_length += Serial1.readBytes(&command_data[data_length],1024*2);
            data_length += uart_read_bytes(IS3_usart_port,&command_data[data_length],1024*2,10);
            a = 2;
        }
        
        // if(a< 10) a--;
        vTaskDelay(1);
    }
    if (data_length <= 0)     
    {
        IS3::read_sta = 0;
        return -1;
    }
    data_length = IRIS_Cut_Befor_Header(command_data, data_length);
    int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,data_type,read_buf);
    if (ret < 0)    
    {
        IS3::read_sta = 0;
        memset(read_buf,0,sizeof(read_buf));
        return -1;
    }
    IS3::read_sta = 0;
    return ret;
}

bool IS3::get_is3_info(String *is3_info)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x50,&data,1);
    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if (data_lenth  <= 0 || data_type != 0x50)    
    {
        return false;
    }
    *is3_info  = String(command_data,data_lenth);
    IS3::info = *is3_info;
    return true;
}

bool IS3::set_shutter_time(uint32_t shutter_time)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data[4]={0,0,0,0};
    data[0] |= shutter_time >> 24;
    data[1] |= shutter_time >> 16;
    data[2] |= shutter_time >> 8;
    data[3] |= shutter_time ;
    IS3::write(0x51,data,4);

    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if (data_type != 0x51)    
    {
        return false;
    }
    IS3::integration_time = shutter_time;
    return true;
}

//有问题
bool IS3::opt()
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x52,&data,1);
    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x52)    
    {
        return false;
    }
    return true;
}


bool IS3::get_shutter_time(uint32_t *shutter_time)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x53,&data,1);

    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if (data_lenth  <= 0 || data_type != 0x53)    
    {
        return false;
    }
    *shutter_time = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
    IS3::integration_time = *shutter_time;
    return true;
}


bool IS3::get_is3_temperature(float *temp)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x54,&data,1);

    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if (data_lenth  <= 0 || data_type != 0x54)    
    {
        return false;
    }
    *temp = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
    IS3::temperature = *temp;
    return true;
}


bool IS3::close_shutter()
{
    if(IS3::read_sta == 1) return false;
    uint8_t shutter_num = 1;
    IS3::write(0x55,&shutter_num,1);

    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x55)
    {
        return false;
    }
    return true;
}

bool IS3::open_shutter()
{
    if(IS3::read_sta == 1) return false;
    uint8_t shutter_num = 1;
    IS3::write(0x56,&shutter_num,1);
    
    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x56)
    {
        return false;
    }
    return true;
}

bool IS3::get_bandnum(uint32_t *is3_bandnum)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x57,&data,1);
    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x57)
    {
        return false;
    }
    *is3_bandnum = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
    IS3::bandnum = *is3_bandnum;
    return true;
}


// bool set_bochangxishu(struct bochangxishu *bochangxishu);
// bool IS3::set_bochangxishu(double aa1,double aa2,double aa3,double aa4)
// {
//     uint8_t bochangxishu[32] = {0};


//     IS3::write(0x58, (uint8_t *)bochangxishu, 32);

//     uint8_t data_type;
//     uint8_t command_data[20];
//     int data_lenth  = IS3::read(&data_type,command_data);
//     if(data_lenth  <= 0 || data_type != 0x58)
//     {
//         return false;
//     }
//     return true;
// }

// 转换每个 double 为大端格式并写入缓冲区
void double_to_big_endian(double value, uint8_t* out) {
    uint8_t* p = (uint8_t*)&value;
    for (int i = 0; i < 8; ++i) {
        out[i] = p[7 - i]; // 反转字节序
    }
}

bool IS3::set_bochangxishu(double aa1, double aa2, double aa3, double aa4)
{
    if(IS3::read_sta == 1) return false;
    uint8_t bochangxishu[32] = {0}; // 4 * 8 = 32 bytes

    // 转换每个 double 为大端格式并写入缓冲区
    double_to_big_endian(aa1, &bochangxishu[0]);
    double_to_big_endian(aa2, &bochangxishu[8]);
    double_to_big_endian(aa3, &bochangxishu[16]);
    double_to_big_endian(aa4, &bochangxishu[24]);

    // 写入地址 0x58
    IS3::write(0x58, bochangxishu, 32);

    // 读取设备返回数据
    uint8_t data_type;
    uint8_t command_data[20];
    
    int data_lenth = IS3::read(&data_type, command_data);

    // 检查响应类型是否正确
    if (data_lenth <= 0 || data_type != 0x58) {
        return false;
    }
    IS3::a1 = aa1;
    IS3::a2 = aa2;
    IS3::a3 = aa3;
    IS3::a4 = aa4;

    return true;
}

// 从大端格式转换为 double（适配 ESP32 小端架构）
double big_endian_to_double(const uint8_t* in) {
    uint8_t temp[8];
    for (int i = 0; i < 8; ++i) {
        temp[i] = in[7 - i]; // 字节反转
    }
    double result;
    memcpy(&result, temp, sizeof(double));
    return result;
}

bool IS3::get_bochangxishu(double *aa1, double *aa2, double *aa3, double *aa4)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data = 0;
    IS3::write(0x59, &data, 1);

    uint8_t data_type;
    uint8_t command_data[32];
    
    int data_lenth = IS3::read(&data_type, command_data);

    if(data_lenth <= 0 || data_type != 0x59) {
        return false;
    }

    // 解码 4 个 double（每个 8 字节，大端）
    *aa1 = big_endian_to_double(&command_data[0]);
    *aa2 = big_endian_to_double(&command_data[8]);
    *aa3 = big_endian_to_double(&command_data[16]);
    *aa4 = big_endian_to_double(&command_data[24]);

    // 可选：存到 IS3 的静态成员变量中（如果需要）
    IS3::a1 = *aa1;
    IS3::a2 = *aa2;
    IS3::a3 = *aa3;
    IS3::a4 = *aa4;

    return true;
}

bool IS3::set_data_processing(enum IS3_data_processing IS3_data_processing,uint32_t average_num)
{
    if(IS3::read_sta == 1) return false;
    uint8_t data_buff[5];
    switch (IS3_data_processing)
    {
        case none:
            data_buff[0] = 0;
            break;
        case average: 
            data_buff[0] = 1;
            break;
        case sgi: 
            data_buff[0] = 2;
            break;
        case average_sgi: 
            data_buff[0] = 3;
            break;
        case move_average: 
            data_buff[0] = 4;
            break;
        default:
            break;
    }
    // memcpy(data_buff+1,(uint8_t *)&average_num, 5);
    
    data_buff[1] |= average_num >> 24;
    data_buff[2] |= average_num >> 16;
    data_buff[3] |= average_num >> 8;
    data_buff[4] |= average_num;

    IS3::write(0x60,data_buff, 5);

    uint8_t data_type;
    uint8_t command_data[32];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x60)
    {
        return false;
    }
    return true;
}   


bool IS3::get_data(uint8_t *data)
{
    if(IS3::read_sta == 1) return false;
    uint8_t b = 0 ;
    IS3::write(0x61,&b, 1);
    uint8_t data_type;
    int data_lenth  = IS3::read(&data_type,data);
    
    if(data_lenth  <= 0 || data_type != 0x61)
    {
        memset(data,0,515*2);
        return false;
    }

    return true;
}


// bool IS3::get_data(uint8_t *data)
// {
//     uint8_t b = 0 ;
//     unsigned char command_data[1024 * 2];
//     uint16_t  data_length = 0;
//     int a  = is3.integration_time * 3;
//     uint8_t data_type;
//     IS3::write(0x61,&b, 1);
//     while(a--)
//     {
//         while(Serial1.available()) 
//         {
//             data_length += Serial1.readBytes(&command_data[data_length],1024*2);
//             a = 10;
//         }
//         if(data_length == 1037) break;
//         // if(a <= 10 ) a--;
//         vTaskDelay(1);
//     }

//     data_length = IRIS_Cut_Befor_Header(command_data, data_length);
//     int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,&data_type,data);
    
//     if (ret < 0)    
//     {
//         return false;
//     }

//     if(data_type != 0x61)
//     {
//         return false;
//     }

//     return true;
// }



bool IS3::get_data_processing(uint8_t *is3_processing)
{
    if(IS3::read_sta == 1) return false;
    uint8_t b = 0 ;
    IS3::write(0x62,&b, 1);
    uint8_t data_type;
    uint8_t command_data[32];
    
    int data_lenth  = IS3::read(&data_type,command_data);
    if(data_lenth  <= 0 || data_type != 0x62)
    {
        return false;
    }
    *is3_processing = command_data[0];
    IS3::is3_processing = *is3_processing;
    return true;
}