#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
use core::str;
use std::fs;
use std::fs::File;
use std::io::{Write};
// use std::sync::WaitTimeoutResult;
use std::path::Path;
use std::mem;

use super::mylog::*;
use super::serport::serport::*;
use super::mydefine::*;



pub fn savecalibratefile_iris(gain: Vec<f32>, shutter: u32, direction: bool, filepath: String) -> String {
    let mut data = IS11DataStruct::default();
    let lenthofgain = gain.len() ;
    for i in 0..lenthofgain {
        
    
        data.data[i] = gain[i];
    } 
    

    data.shutter_time = shutter as u32;
    data.direction = if direction { 1 } else { 0 };
    data.datatype = 0x04;
    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];

    // 序列化为二进制数据
    unsafe {
        let ptr = &data as *const IS11DataStruct as *const u8;
        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
    }
    // 序列化为二进制数据
    let file_path = Path::new(&filepath);

    // 获取文件路径的父目录
    if let Some(parent) = file_path.parent() {
        // 确保父目录存在
        if !parent.exists() {
            fs::create_dir_all(parent).unwrap();
            println!("父目录已创建: {:?}", parent);
        } else {
            println!("父目录已存在: {:?}", parent);
        }
    } else {
        println!("文件路径没有父目录");
    }
    let mut file = File::create(filepath).unwrap();
    file.write_all(&buffer).unwrap();

    "OK".to_string()
}



pub fn sendcalibratetodev_iris(gain: Vec<f32>, shutter: u32, direction: bool) -> String {
    let mut data = IS11DataStruct::default();
    if gain.len() != data.data.len() {
        logtorust(format!["Gain data length error"]);
        return "Gain data length error".to_string();
        
    }
    data.data = gain.as_slice().try_into().unwrap();
    data.shutter_time = shutter as u32;
    data.direction = if direction { 1 } else { 0 };
    data.datatype = 0x04;
    let mut buffer = vec![0u8; mem::size_of::<IS11DataStruct>()];
    // 序列化为二进制数据
    unsafe {
        let ptr = &data as *const IS11DataStruct as *const u8;
        std::ptr::copy_nonoverlapping(ptr, buffer.as_mut_ptr(), mem::size_of::<IS11DataStruct>());
    }
    sendtoportbinary_iris(buffer, 0x03);
    "OK".to_string()
}

pub fn sendtoportbinary_iris(data: Vec<u8>, command: u8) -> String {
    let lenth = data.len() as u16;
    let high: u8 = (lenth >> 8) as u8;
    let low: u8 = (lenth & 0xFF) as u8;
    let mut header = vec![];
    header.push(0x55);
    header.push(0xAA);
    let mut crcbody = vec![];
    // crcbody.push(high);
    // crcbody.push(low);
    crcbody.extend(data);
    let crc = iris_calc_crc(&crcbody);
    let crchigh: u8 = (crc >> 8) as u8;
    let crclow: u8 = (crc & 0xFF) as u8;
    let mut senddata = vec![];
    senddata.extend(header);
    senddata.push(command);
    senddata.push(high);
    senddata.push(low);
    senddata.extend(crcbody);
    senddata.push(crchigh);
    senddata.push(crclow);

    //  println!("sendtoport data:{}",senddata.len());
    println!(
        "sendtoport data content:{:X?}",
        senddata
            .iter()
            .map(|&byte| format!("{:02X}", byte))
            .collect::<Vec<String>>()
            .join(" ")
    );
    sendtoprot(senddata);
    "send ok".to_string()
}

// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command

pub fn greet_iris(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

pub fn getportnames_iris() -> Vec<String> {
    get_port_name()
}


pub fn opencom_iris(portname: serde_json::Value, baudrate: serde_json::Value) -> String {
    //tauri
    let portname = portname.as_str().unwrap();
    let baudrate = baudrate.as_u64().unwrap() as u32;
    set_port_info(&portname.to_string(), baudrate);

    println!("opencom portname:{} baudrate:{}", portname, baudrate);
    logtorust(format!(
        "opencom portname:{} baudrate:{}",
        portname, baudrate
    ));
    tryuseport()
}

pub fn closecome_iris() -> String {
    closeport()
}

pub fn sendtoport_iris(data: serde_json::Value, datatype: serde_json::Value) -> String {
    // println!("sendtoport data:{}",data.to_string());
    //判断是否存在data
    // if !data.is_object() {
    //     return String::from("Invalid data");
    // }
    println!("sendtoport data:{}", data.to_string());
    logtorust(format!("sendtoport data:{}", data.to_string()));
    let data = data.to_string().as_bytes().to_vec();
    let lenth = data.len() as u16;
    let high: u8 = (lenth >> 8) as u8;
    let low: u8 = (lenth & 0xFF) as u8;
    let mut header = vec![];
    header.push(0x55);
    header.push(0xAA);
    let mut command: u8 = 0;
    let datatype = datatype.as_str().unwrap();
    println!("datatype:{}", datatype);
    if datatype == "hex" {
        command = 0x03;
    }
    if datatype == "string" {
        command = 0x01;
    }
    if datatype == "json" {
        command = 0x00;
    }
    let mut crcbody = vec![];
    // crcbody.push(high);
    // crcbody.push(low);
    crcbody.extend(data);
    let crc = iris_calc_crc(&crcbody);
    let crchigh: u8 = (crc >> 8) as u8;
    let crclow: u8 = (crc & 0xFF) as u8;
    let mut senddata = vec![];
    senddata.extend(header);
    senddata.push(command);
    senddata.push(high);
    senddata.push(low);
    senddata.extend(crcbody);
    senddata.push(crchigh);
    senddata.push(crclow);

    //  println!("sendtoport data:{}",senddata.len());
    // println!(
    //     "sendtoport data content:{:X?}",
    //     senddata
    //         .iter()
    //         .map(|&byte| format!("{:02X}", byte))
    //         .collect::<Vec<String>>()
    //         .join(" ")
    // );
    logtorust(format!(
        "sendtoport data content:{:X?}",
        senddata
            .iter()
            .map(|&byte| format!("{:02X}", byte))
            .collect::<Vec<String>>()
            .join(" ")
    ));

    sendtoprot(senddata);
    "send ok".to_string()
}


pub fn readformport_iris(commanid: serde_json::Value, wait_time_json: serde_json::Value) -> String {
    let mut waittime = 50;
    if wait_time_json.is_u64() {
        waittime = wait_time_json.as_u64().unwrap() as u32;
    }

    let commanid = commanid.as_u64().unwrap() as u8;
    let ret = readdatafromport(waittime as u64, commanid);
    let str = String::from_utf8_lossy(&ret);
    println!("read data: {}", str);
    return str.to_string();
}
pub fn set_weave_coeff_iris(specnumber: i32, a0: f64, a1: f64, a2: f64, a3: f64) -> String {
     logtorust(format!(
        "set_weave_coeff_iris specnumber:{} a0:{} a1:{} a2:{} a3:{}",
        specnumber, a0, a1, a2, a3
    ));
    // 新建一个serde_json对象
    /* 
    {
            "command": "set_bochangxishu",
                "bochangxishu": {
                "a0": -1.08988798e-09,
                "a1": -5.32620063e-05,
                "a2": 0.441532,
                "a3": 348.5026,
                "b0": -1.2597071e-9,
                "b1": -0.000053,
                "b2": 0.440609,
                "b3": 48.3989
            }
        }
        */
    let mut data = serde_json::Map::new();
    data.insert("command".to_string(), serde_json::Value::String("set_bochangxishu".to_string()));
    let mut bochangxishu = serde_json::Map::new();
    bochangxishu.insert("a0".to_string(), serde_json::Value::from(a0));
    bochangxishu.insert("a1".to_string(), serde_json::Value::from(a1));
    bochangxishu.insert("a2".to_string(), serde_json::Value::from(a2));
    bochangxishu.insert("a3".to_string(), serde_json::Value::from(a3));
    bochangxishu.insert("b0".to_string(), serde_json::Value::from(a0));
    bochangxishu.insert("b1".to_string(), serde_json::Value::from(a1));
    bochangxishu.insert("b2".to_string(), serde_json::Value::from(a2));
    bochangxishu.insert("b3".to_string(), serde_json::Value::from(a3));
    data.insert("bochangxishu".to_string(), serde_json::Value::Object(bochangxishu));
    let data = serde_json::Value::Object(data);
   let resut= sendtoport_andgetreturn_iris(data, serde_json::Value::String("json".to_string()));
    println!("set_weave_coeff_iris result: {:?}", resut.as_ref().unwrap().content);

    "OK".to_string()
}

pub fn sendtoport_andgetreturn_iris(
    data: serde_json::Value,
    datatype: serde_json::Value,
) -> Result<RetStruct, String> {
    // println!("sendtoport data:{}",data.to_string());
    //判断是否存在data
    // if !data.is_object() {
    //     return String::from("Invalid data");
    // }

    //println!("sendtoport data:{}", data.to_string());

    let command = data.get("command").unwrap().to_string();
    let mut isneedlog = true;
    let mut isgetdata = false;
    if command == "\"get_caiji_state\"" {
        isneedlog = false;
    }
if command == "\"get_data\"" {
    isgetdata = true;
    
}

    if isneedlog {
        logtorust(format!("sendtoport data:{}", data.to_string()));
    }

    let data = data.to_string().as_bytes().to_vec();
    let lenth = data.len() as u16;
    let high: u8 = (lenth >> 8) as u8;
    let low: u8 = (lenth & 0xFF) as u8;
    let mut header = vec![];
    header.push(0x55);
    header.push(0xAA);
    let mut command: u8 = 0;
    let datatype = datatype.as_str().unwrap();
    println!("datatype:{}", datatype);
    if datatype == "hex" {
        command = 0x03;
    }
    if datatype == "string" {
        command = 0x01;
    }
    if datatype == "json" {
        command = 0x00;
    }
    let mut crcbody = vec![];
    // crcbody.push(high);
    // crcbody.push(low);
    crcbody.extend(data);
    let crc = iris_calc_crc(&crcbody);
    let crchigh: u8 = (crc >> 8) as u8;
    let crclow: u8 = (crc & 0xFF) as u8;
    let mut senddata = vec![];
    senddata.extend(header);
    senddata.push(command);
    senddata.push(high);
    senddata.push(low);
    senddata.extend(crcbody);
    senddata.push(crchigh);
    senddata.push(crclow);

    println!("sendtoport data:{}", senddata.len());
    // println!(
    //     "sendtoport data content:{:X?}",
    //     senddata
    //         .iter()
    //         .map(|&byte| format!("{:02X}", byte))
    //         .collect::<Vec<String>>()
    //         .join(" ")
    // );
    if isneedlog {
        logtorust(format!(
            "sendtoport data content:{:X?}",
            senddata
                .iter()
                .map(|&byte| format!("{:02X}", byte))
                .collect::<Vec<String>>()
                .join(" ")
        ));
    }

    sendtoprot(senddata);
    let mut ret = readdatafromport(50, 0xff);
    let datatype = ret[0];
  
    if isneedlog {
        if !isgetdata{
        logtorust(format!(
            "read content: {:X?}",
            ret.iter()
                .map(|&byte| format!("{:02X}", byte))
                .collect::<Vec<String>>()
                .join(" ")
        ));
        }
    }
    if isgetdata{
        logtorust("Get data Back SUCCESS".to_string());
        logtorust("_____________________________one_data_over_____________________________\n".to_string());
    }


    ret.remove(0);
    ret.remove(0);
    ret.remove(0);
    if datatype == 0x02 {
        let mut is11data = IS11DataStruct::default();
        unsafe {
            let is11data_ptr = &mut is11data as *mut IS11DataStruct;
            let ret_ptr = &mut ret[0] as *mut u8;
            std::ptr::copy_nonoverlapping(
                ret_ptr,
                is11data_ptr as *mut u8,
                std::mem::size_of::<IS11DataStruct>(),
            );
            return Ok(RetStruct {
                datatype: datatype,
                content: "null".to_string(),
                data: is11data,
            });
        }
    }

    let str = String::from_utf8_lossy(&ret);
    // println!("read data: {}", str);
    if datatype==0x00 &&isneedlog {
        logtorust(format![
            "read string: {}",
            str.to_string()
        ]);
        
    }
    return Ok(RetStruct {
        datatype: datatype,
        content: str.to_string(),
        data: IS11DataStruct::default(),
    });

    //    return str.to_string();
}

pub fn clearportbuff_iris() -> String {
    clearserilport()
}

pub fn setport_iris(data: serde_json::Value) -> String {
    //判断是否存在portname和baudrate
    if !data.is_object() {
        return String::from("Invalid data");
    }
    if !data["portname"].is_string() || !data["baudrate"].is_u64() {
        return String::from("Invalid data");
    }
    let portname = data["portname"].as_str().unwrap();
    let baudrate = data["baudrate"].as_u64().unwrap() as u32;
    set_port_info(&portname.to_string(), baudrate);
    //println!("{}",readdatafromport(1000));
    String::from("Port set ok")
}