use clap::{Parser};

pub mod asotr_data {
    use std::{fs::File, io::Read};
    use byteorder::{LittleEndian, ReadBytesExt};
    use chrono::{DateTime, Utc};
    use std::time::{SystemTime, UNIX_EPOCH, Duration};
    use strum::FromRepr;
    use lazy_static::lazy_static;
    use regex::Regex;
    use walkdir::WalkDir;

    lazy_static! {
        pub static ref support_dtypes: String = 
            String::from(".data01.asotr01(02), data02.asotr01(02), data06.asotr01(02)");

        pub static ref patterns_fnames_csv_data: Vec<(String, String)> = {
            let mut patterns: Vec<(String, String)> = Vec::new();
            patterns.push((String::from(".*data01.asotr01"), 
                           String::from("../data/asotr/asotr01_data_T.csv")));
            patterns.push((String::from(".*data02.asotr01"), 
                           String::from("../data/asotr/asotr01_data_P.csv")));
            patterns.push((String::from(".*data06.asotr01"), 
                           String::from("../data/asotr/asotr01_data_TSET.csv")));
            patterns.push((String::from(".*data01.asotr02"), 
                           String::from("../data/asotr/asotr02_data_T.csv")));
            patterns.push((String::from(".*data02.asotr02"), 
                           String::from("../data/asotr/asotr02_data_P.csv")));
            patterns.push((String::from(".*data06.asotr02"), 
                           String::from("../data/asotr/asotr02_data_TSET.csv")));

            patterns
        };

        pub static ref patterns_disp: Vec<String> = {
            let mut patterns: Vec<String> = Vec::new();
            patterns.push(String::from("ASOTR01 temperature"));
            patterns.push(String::from("ASOTR01 power"));
            patterns.push(String::from("ASOTR01 temperature setpoint"));
            patterns.push(String::from("ASOTR02 temperature"));
            patterns.push(String::from("ASOTR02 power"));
            patterns.push(String::from("ASOTR02 temperature setpoint"));
            patterns
        };
    }

    #[derive(Debug, FromRepr, PartialEq)]
    enum AsotrDataType {
        Temp = 1,
        Pow = 2,
        TempSet = 6,
    }

    struct AsotrDataDesc {
        time_s: u64,
        time_mks: u32,
        date: String,
        time: String,
        data_type: AsotrDataType,
        // kit: u8,
    }

    impl AsotrDataDesc {
        pub fn new(time_s: u64, time_mks: u32, date: String, time: String, 
                   data_type: AsotrDataType) -> AsotrDataDesc {
            AsotrDataDesc { time_s, time_mks, date, time, data_type }
        }
    } 

    pub fn read_data(filename_full: String) -> Result<String, String> {
        let ch_u16: [u16; 6];
        let ch_f32: [f32; 6];

        let asotr_head = parse_filename(filename_full.clone())?;

        let mut buf = Vec::new();
        let mut out = String::new();

        let mut data = match File::open(filename_full.clone())
        {
            Ok(file) => file,
            Err(msg) => { return Err(format!("Error opening data file {}: {}", filename_full, msg)) }
        };

        match data.read_to_end(&mut buf) {
            Ok(stat) => stat,
            Err(msg) => { return Err(format!("Error reading data file {}: {}", filename_full, msg)) }
        };

        out.push_str(&format!("{};{} {}.{:02};", 
                              &asotr_head.time_s,
                              &asotr_head.date,
                              &asotr_head.time, 
                              asotr_head.time_mks));

        if asotr_head.data_type == AsotrDataType::Temp || 
            asotr_head.data_type == AsotrDataType::TempSet {
                ch_f32 = parse_data_f32(buf)?;
                for elem in ch_f32 { 
                    out.push_str(&elem.to_string());  
                    out.push(';');
                }
            }
        else if asotr_head.data_type == AsotrDataType::Pow {
            ch_u16 = parse_data_u16(buf)?;
            for elem in ch_u16 { 
                out.push_str(&elem.to_string());  
                out.push(';');
            }
        }

        out.remove(out.len() - 1);
        return Ok(out);
    }

    pub fn parse_data_dir(dir: &str, disp: bool) -> Result<(), String> {
        let mut data: Vec<String> = Vec::new();

        println!("parse data from directory: {}", dir);
        for (i, (pattern, fname)) in patterns_fnames_csv_data.iter().enumerate() {
            let files = find_files_regex(dir, pattern)?;

            for elem in files {
                data.push(read_data(elem)?);
            }

            data.sort();
            data.dedup();

            if disp { disp_data(&data, &patterns_disp[i])?; }

            println!("save csv data to file: {}", fname);

            save_data_csv(data.clone(), fname)?;
            data.clear();
        }

        return Ok(());
    }

    fn parse_data_f32(buf: Vec<u8>) -> Result<[f32; 6], String> {
        let mut data = &buf[..];
        let mut ch: [f32; 6] = [0.0; 6];

        for i in 0..6 {
            ch[i] = match data.read_f32::<LittleEndian>() {
                Ok(val) => val,
                Err(msg) => { 
                    return Err(format!(
                            "Error parsing file: failed parsing float32 data: {}", msg)); }
            }
        }

        return Ok(ch);
    }

    fn parse_data_u16(buf: Vec<u8>) -> Result<[u16; 6], String> {
        let mut data = &buf[..];
        let mut ch: [u16; 6] = [0; 6];

        for i in 0..6 {
            ch[i] = match data.read_u16::<LittleEndian>() {
                Ok(val) => val,
                Err(msg) => { 
                    return Err(format!(
                            "Error parsing file: failed parsing uint16 data: {}", msg)); }
            }
        }

        return Ok(ch);
    }

    fn parse_filename(filename_full: String) -> Result<AsotrDataDesc, String> {
        let mut fname = String::new();
        let msg_prev = format!("Error parsing filename {}:", filename_full);

        match filename_full.rfind('/') {
            Some(val) => { fname = (filename_full[val+1..filename_full.len()]).to_string(); }
            _ => { fname = filename_full.clone();  }
        }

        if fname.len() != 32 { 
            return Err(format!("{} unsupported file", msg_prev)); 
        }

        let time_unix_ = fname[0..10].parse::<u64>();
        let time_unix = match &time_unix_ {
            Ok(data) => data,
            Err(msg) => { 
                return Err(format!("{} expected digits in timestamp sec part ({})", 
                                   msg_prev, msg));  
            }
        };

        let data_type_ = fname[22..24].parse::<u8>();
        let data_type_u8 = match &data_type_ {
            Ok(data) => data,
            Err(msg) => { 
                return Err(format!("{} expected digits in data type part ({})", 
                                   msg_prev, msg));  
            }
        };

        if *data_type_u8 == 1 || *data_type_u8 == 2 || *data_type_u8 == 6 { }
        else {
            return Err(format!("{} parser supports data types: {}", 
                               msg_prev, support_dtypes.to_string()));
        }

        let data_type = match AsotrDataType::from_repr(*data_type_u8 as usize) {
            Some(value) => value,
            _ => return Err(format!("{} expected digits in data type part", 
                                    msg_prev))
        };

        // let _kit = filename[30..32].parse::<u8>();
        // let kit = match &_kit {
        //     Ok(data) => data,
        //     Err(msg) => { return Err(format!("{}: expected digits in asotr kit part ({})", 
        //                                      msg_prev, msg));  }
        // };

        let _time_str_mks = fname[11..14].parse::<u32>();
        let time_mks = match &_time_str_mks {
            Ok(data) => data,
            Err(msg) => { return Err(format!("{}: expected digits in timestamp mks part ({})", 
                                             msg_prev, msg));  }
        };

        let time: SystemTime = UNIX_EPOCH + Duration::from_secs(*time_unix);
        let date_time = DateTime::<Utc>::from(time);
        let date_s = date_time.format("%d.%m.%Y").to_string();
        let time_s = date_time.format("%H:%M:%S").to_string();

        let head = AsotrDataDesc::new(*time_unix, *time_mks, date_s, time_s, data_type);

        return Ok(head);
    }

    fn find_files_regex(dir: &str, template: &str) -> Result<Vec<String>, String> {
        let mut path_vec: Vec<String> = Vec::new();

        let regex = match Regex::new(template) {
            Ok(val) => val,
            Err(msg) => { 
                return Err(format!("Error create regex template ({}): {}",
                template, msg)); 
            }
        };

        let data = WalkDir::new(dir)
            .into_iter()
            .filter_map(|e| e.ok())
            .filter(|e| regex.is_match(e.file_name().to_str().unwrap()))
            .map(|e| e.into_path());

        for elem in data {
            path_vec.push(elem.display().to_string());
        }

        if path_vec.len() == 0 { 
            return Err(format!(
                    "Error searching files for pattern ({}): files not found in directory {}", 
                    template, dir));  
        }

        return Ok(path_vec);
    }

    fn disp_data(data: &Vec<String>, about: &str) -> Result<(), String> {
        println!("{}", about);
        println!("{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}", 
                 "timestamp_sec", "timestamp", 
                 "ch1", "ch2", "ch3", "ch4", "ch5", "ch6");

        for elem in data {
            println!("{}", elem.replace(';', "\t"));
        }

        return Ok(())
    }

    fn save_data_csv(data: Vec<String>, fname: &str) -> Result<(), String> {

        let mut data_w: Vec<String> = Vec::new();
        data_w.push(format!("{};{};{};{};{};{};{};{}", 
                            "timestamp_sec", "timestamp", 
                            "ch1", "ch2", "ch3", "ch4", "ch5", "ch6"));

        for elem in data {
            data_w.push(elem);
        }

        match std::fs::write(fname, data_w.join("\n")) {
            Ok(f) => f,
            Err(msg) => { 
                return Err(format!("Error write data to csv file {}: {}", fname, msg)) 
            }
        }

        return Ok(());
    }
}

#[derive(Parser, Debug)]
#[command(version, author, about, long_about = None)]
struct Cli {
    /// file with ASOTR MVN data (.data01.asotr01(02), data02.asotr01(02), data06.asotr01(02))
    #[arg(long, short = 'f', value_name = "FILE_DATA")]
    filename: Option<String>,

    /// directory with ASOTR MVN data
    #[arg(long, short = 'd', value_name = "DIRECTORY_DATA")]
    directory: Option<String>,

    /// show data in console
    #[arg(short = 's')]
    show: bool,
}


fn main() {
    use crate::asotr_data::*; 

    let cli = Cli::parse();
    let show = cli.show;

    if let Some(fname) = &cli.filename {

        let s = match read_data(fname.clone()) {
            Ok(elem) => elem,
            Err(msg) => { println!("{}", msg); return; } 
        };

        println!("{}", s);

        return;
    }

    if let Some(dir) = &cli.directory {
        match parse_data_dir(&dir.clone(), show) {
            Ok(elem) => elem,
            Err(msg) => { println!("{}", msg); return; }
        } 
        return;
    }

    println!("Unexpected command. Type --help for more iformation");
}