use std::{
    borrow::BorrowMut,
    collections::HashMap,
    fmt::Display,
    sync::{Arc, Mutex},
};

use ecu_diagnostics::{
    kwp2000::{
        self, KWP2000Command, Kwp2000Cmd, Kwp2000DiagnosticServer, SessionType, VehicleInfo,
    },
    DiagError, DiagServerResult, DiagnosticServer,
};
use eframe::{
    egui::{
        self,
        plot::{Bar, BarChart, CoordinatesFormatter, HLine, Legend, Line, LineStyle, PlotPoints},
        Layout, TextEdit, RichText, Response,
    },
    epaint::{vec2, Color32, Stroke, FontId, TextShape},
};
use egui_extras::{Size, Table, TableBuilder};
use egui_toast::ToastKind;
use nom::number::complete::le_u16;
mod map_widget;
mod help_view;
mod map_list;
use map_list::MAP_ARRAY;
use crate::window::PageAction;

use self::{map_widget::MapWidget, help_view::HelpView};

use super::{
    configuration::{
        self,
        cfg_structs::{EngineType, TcmCoreConfig},
    },
    status_bar::MainStatusBar,
};

#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum MapCmd {
    Read = 0x01,
    ReadDefault = 0x02,
    Write = 0x03,
    Burn = 0x04,
    ResetToFlash = 0x05,
    Undo = 0x06,
    ReadMeta = 0x07,
    ReadEEPROM = 0x08
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum MapViewType {
    EEPROM,
    Default,
    Modify,
}

#[derive(Debug, Clone)]
pub struct Map {
    meta: MapData,
    x_values: Vec<i16>,
    y_values: Vec<i16>,
    eeprom_key: String,
    /// EEPROM data
    data_eeprom: Vec<i16>,
    /// Map data in memory NOW
    data_memory: Vec<i16>,
    /// Program default map
    data_program: Vec<i16>,
    /// User editing map
    data_modify: Vec<i16>,
    showing_default: bool,
    ecu_ref: Arc<Mutex<Kwp2000DiagnosticServer>>,
    curr_edit_cell: Option<(usize, String, Response)>,
    view_type: MapViewType
}

fn read_i16(a: &[u8]) -> DiagServerResult<(&[u8], i16)> {
    if a.len() < 2 {
        return Err(DiagError::InvalidResponseLength);
    }
    let r = i16::from_le_bytes(a[0..2].try_into().unwrap());
    Ok((&a[2..], r))
}

fn read_u16(a: &[u8]) -> DiagServerResult<(&[u8], u16)> {
    if a.len() < 2 {
        return Err(DiagError::InvalidResponseLength);
    }
    let r = u16::from_le_bytes(a[0..2].try_into().unwrap());
    Ok((&a[2..], r))
}

impl Map {
    pub fn new(
        map_id: u8,
        server: Arc<Mutex<Kwp2000DiagnosticServer>>,
        meta: MapData,
    ) -> DiagServerResult<Self> {
        // Read metadata
        let mut s = server.lock().unwrap();
        let mut ecu_response = &s.send_byte_array_with_response(&[
            KWP2000Command::ReadDataByLocalIdentifier.into(),
            0x19,
            map_id,
            MapCmd::ReadMeta as u8,
            0x00,
            0x00,
        ])?[1..];
        let (data, data_len) = read_u16(ecu_response)?;
        if data.len() != data_len as usize {
            return Err(DiagError::InvalidResponseLength);
        }
        let (data, x_element_count) = read_u16(data)?;
        let (data, y_element_count) = read_u16(data)?;
        let (mut data, key_len) = read_u16(data)?;
        if data.len() as u16 != ((x_element_count + y_element_count) * 2) + key_len {
            return Err(DiagError::InvalidResponseLength);
        }
        let mut x_elements: Vec<i16> = Vec::new();
        let mut y_elements: Vec<i16> = Vec::new();
        for _ in 0..x_element_count {
            let (d, v) = read_i16(data)?;
            x_elements.push(v);
            data = d;
        }
        for _ in 0..y_element_count {
            let (d, v) = read_i16(data)?;
            y_elements.push(v);
            data = d;
        }
        let key = String::from_utf8(data.to_vec()).unwrap();

        let mut default: Vec<i16> = Vec::new();
        let mut current: Vec<i16> = Vec::new();
        let mut eeprom : Vec<i16> = Vec::new();

        // Read current data
        let ecu_response = &s.send_byte_array_with_response(&[
            KWP2000Command::ReadDataByLocalIdentifier.into(),
            0x19,
            map_id,
            MapCmd::Read as u8,
            0x00,
            0x00,
        ])?[1..];
        let (mut c_data, c_arr_size) = read_u16(ecu_response)?;
        if c_data.len() != c_arr_size as usize {
            return Err(DiagError::InvalidResponseLength);
        }
        for _ in 0..(c_arr_size / 2) {
            let (d, v) = read_i16(c_data)?;
            current.push(v);
            c_data = d;
        }

        // Read default data
        let ecu_response = &s.send_byte_array_with_response(&[
            KWP2000Command::ReadDataByLocalIdentifier.into(),
            0x19,
            map_id,
            MapCmd::ReadDefault as u8,
            0x00,
            0x00,
        ])?[1..];
        let (mut d_data, d_arr_size) = read_u16(ecu_response)?;
        if d_data.len() != d_arr_size as usize {
            return Err(DiagError::InvalidResponseLength);
        }
        for _ in 0..(d_arr_size / 2) {
            let (d, v) = read_i16(d_data)?;
            default.push(v);
            d_data = d;
        }
        
        let ecu_response = &s.send_byte_array_with_response(&[
            KWP2000Command::ReadDataByLocalIdentifier.into(),
            0x19,
            map_id,
            MapCmd::ReadEEPROM as u8,
            0x00,
            0x00,
        ])?[1..];
        drop(s); // Drop Mutex lock
        let (mut e_data, e_arr_size) = read_u16(ecu_response)?;
        if e_data.len() != e_arr_size as usize {
            return Err(DiagError::InvalidResponseLength);
        }
        for _ in 0..(e_arr_size / 2) {
            let (d, v) = read_i16(e_data)?;
            eeprom.push(v);
            e_data = d;
        }

        Ok(Self {
            x_values: x_elements,
            y_values: y_elements,
            eeprom_key: key,
            data_eeprom: eeprom,
            data_memory: current.clone(),
            data_program: default,
            data_modify: current,
            meta,
            showing_default: false,
            ecu_ref: server,
            curr_edit_cell: None,
            view_type: MapViewType::Modify

        })
    }

    fn data_to_byte_array(&self, data: &Vec<i16>) -> Vec<u8> {
        let mut ret = Vec::new();
        ret.extend_from_slice(&((data.len()*2) as u16).to_le_bytes());
        for point in data {
            ret.extend_from_slice(&point.to_le_bytes());
        }
        ret
    }

    pub fn write_to_ram(&self) -> DiagServerResult<()> {
        let mut payload: Vec<u8> = vec![
            KWP2000Command::WriteDataByLocalIdentifier.into(), 
            0x19, 
            self.meta.id,
            MapCmd::Write as u8,
        ];
        payload.extend_from_slice(&self.data_to_byte_array(&self.data_modify));
        self.ecu_ref.lock().unwrap().send_byte_array_with_response(&payload)?;
        Ok(())
    }

    pub fn save_to_eeprom(&self) -> DiagServerResult<()> {
        let payload: Vec<u8> = vec![
            KWP2000Command::WriteDataByLocalIdentifier.into(), 
            0x19, 
            self.meta.id,
            MapCmd::Burn as u8,
            0x00, 0x00
        ];
        self.ecu_ref.lock().unwrap().send_byte_array_with_response(&payload)?;
        Ok(())
    }

    pub fn undo_changes(&self) -> DiagServerResult<()> {
        let payload: Vec<u8> = vec![
            KWP2000Command::WriteDataByLocalIdentifier.into(), 
            0x19, 
            self.meta.id,
            MapCmd::Undo as u8,
            0x00, 0x00
        ];
        self.ecu_ref.lock().unwrap().send_byte_array_with_response(&payload)?;
        Ok(())
    }

    fn get_x_label(&self, idx: usize) -> String {
        if let Some(replace) = self.meta.x_replace {
            format!("{}", replace.get(idx).unwrap_or(&"ERROR"))
        } else {
            format!("{} {}", self.x_values[idx], self.meta.x_unit)
        }
    }

    fn get_y_label(&self, idx: usize) -> String {
        if let Some(replace) = self.meta.y_replace {
            format!("{}", replace.get(idx).unwrap_or(&"ERROR"))
        } else {
            format!("{} {}", self.y_values[idx], self.meta.y_unit)
        }
    }

    fn gen_edit_table(&mut self, raw_ui: &mut egui::Ui) {
        let hash = match self.view_type {
            MapViewType::EEPROM => &self.data_eeprom,
            MapViewType::Default => &self.data_program,
            MapViewType::Modify => &self.data_modify,
        };
        let header_color = raw_ui.visuals().warn_fg_color;
        let cell_edit_color = raw_ui.visuals().error_fg_color;
        if !self.meta.x_desc.is_empty() {
            raw_ui.label(format!("X: {}", self.meta.x_desc));
        }
        if !self.meta.y_desc.is_empty() {
            raw_ui.label(format!("Y: {}", self.meta.y_desc));
        }
        if !self.meta.v_desc.is_empty() {
            raw_ui.label(format!("Values: {}", self.meta.v_desc));
        }
        let mut copy = self.clone();
        let resp = raw_ui.push_id(&hash, |ui| {
            let mut table_builder = egui_extras::TableBuilder::new(ui)
                .striped(true)
                .scroll(false)
                .cell_layout(Layout::left_to_right(egui::Align::Center).with_cross_align(egui::Align::Center))
                .column(Size::initial(60.0).at_least(60.0));
            for _ in 0..copy.x_values.len() {
                table_builder = table_builder.column(Size::initial(70.0).at_least(70.0));
            }
            table_builder.header(15.0, |mut header | {
                header.col(|_| {}); // Nothing in corner cell
                if copy.x_values.len() == 1 {
                    header.col(|_|{});
                } else {
                    for v in 0..copy.x_values.len() {
                        header.col(|u| {
                            u.label(RichText::new(format!("{}", copy.get_x_label(v))).color(header_color));
                        });
                    }
                }
            }).body(|body| {
                body.rows(15.0, copy.y_values.len(), |row_id, mut row| {
                    // Header column
                    row.col(|c| { c.label(RichText::new(format!("{}", copy.get_y_label(row_id))).color(header_color));});
                        
                    // Data columns
                    for x_pos in 0..copy.x_values.len() {
                        row.col(|cell| {
                            match self.view_type {
                                MapViewType::EEPROM => {
                                    cell.label(format!("{}", copy.data_eeprom[(row_id*copy.x_values.len())+x_pos]));
                                },
                                MapViewType::Default => {
                                    cell.label(format!("{}", copy.data_program[(row_id*copy.x_values.len())+x_pos]));
                                },
                                MapViewType::Modify => {
                                    let map_idx = (row_id*copy.x_values.len())+x_pos;
                                    let mut value = format!("{}", copy.data_modify[map_idx]);
                                    if let Some((curr_edit_idx, current_edit_txt, resp)) = &copy.curr_edit_cell {
                                        if *curr_edit_idx == map_idx {
                                            value = current_edit_txt.clone();
                                        }
                                    }
                                    let changed_value = value != format!("{}", copy.data_eeprom[map_idx]);
                                    let mut edit = TextEdit::singleline(&mut value);
                                    if changed_value {
                                        edit = edit.text_color(cell_edit_color);
                                    }
                                    let mut response = cell.add(edit);
                                    if changed_value {
                                        response = response.on_hover_text(format!("Current in EEPROM: {}", copy.data_eeprom[map_idx]));
                                    }
                                    if response.lost_focus() || cell.ctx().input().key_pressed(egui::Key::Enter) {
                                        if let Ok(new_v) = i16::from_str_radix(&value, 10) {
                                            copy.data_modify[map_idx] = new_v;
                                        }
                                        copy.curr_edit_cell = None;
                                    } else if response.gained_focus() || response.has_focus() {
                                        if let Some((curr_edit_idx, current_edit_txt, _resp)) = &copy.curr_edit_cell {
                                            if let Ok(new_v) = i16::from_str_radix(&current_edit_txt, 10) {
                                                copy.data_modify[*curr_edit_idx] = new_v;
                                            }
                                        }
                                        copy.curr_edit_cell = Some((map_idx, value, response));
                                    }
                                }
                            }
                        });
                    }
                })
            });
        });
        *self = copy;
    }

    fn generate_window_ui(&mut self, raw_ui: &mut egui::Ui) -> Option<PageAction> {
        raw_ui.label(format!("EEPROM key: {}", self.eeprom_key));
        raw_ui.label(format!(
            "Map has {} elements",
            self.x_values.len() * self.y_values.len()
        ));
        self.gen_edit_table(raw_ui);
        // Generate display chart
        if self.x_values.len() == 1 {
            // Bar chart
            let mut bars = Vec::new();
            for x in 0..self.y_values.len() {
                // Distinct points
                let value = match self.view_type {
                    MapViewType::Default => self.data_program[x],
                    MapViewType::EEPROM => self.data_eeprom[x],
                    MapViewType::Modify => self.data_modify[x]
                };
                let key = self.get_y_label(x);
                bars.push(Bar::new(x as f64, value as f64).name(key))
            }
            egui::plot::Plot::new(format!("PLOT-{}", self.eeprom_key))
                .allow_drag(false)
                .allow_scroll(false)
                .allow_zoom(false)
                .height(150.0)
                .include_x(0)
                .include_y((self.y_values.len() + 1) as f64 * 1.5)
                .show(raw_ui, |plot_ui| plot_ui.bar_chart(BarChart::new(bars)));
        } else { // Line chart
            let mut lines: Vec<Line> = Vec::new();
            for (y_idx, key) in self.y_values.iter().enumerate() {
                let mut points : Vec<[f64;2]> = Vec::new();
                for (x_idx, key) in self.x_values.iter().enumerate() {
                    let map_idx = (y_idx*self.x_values.len())+x_idx;
                    let data = match self.view_type {
                        MapViewType::Default => self.data_program[map_idx],
                        MapViewType::EEPROM => self.data_eeprom[map_idx],
                        MapViewType::Modify => self.data_modify[map_idx]
                    };
                    points.push([*key as f64, data as f64]);
                }
                lines.push(
                    Line::new(points).name(self.get_y_label(y_idx))
                );
            }
            egui::plot::Plot::new(format!("PLOT-{}", self.eeprom_key))
                .allow_drag(false)
                .allow_scroll(false)
                .allow_zoom(false)
                .height(150.0)
                .width(raw_ui.available_width())
                .show(raw_ui, |plot_ui| {
                    for l in lines {
                        plot_ui.line(l);
                    }
                });

        }
        raw_ui.label("View mode:");
        raw_ui.horizontal(|row| {
            row.selectable_value(&mut self.view_type, MapViewType::Modify, "User changes");
            row.selectable_value(&mut self.view_type, MapViewType::EEPROM, "EEPROM");
            row.selectable_value(&mut self.view_type, MapViewType::Default, "TCU default");
        });
        if self.data_modify != self.data_eeprom {
            if raw_ui.button("Undo user changes").clicked() {
                return match self.undo_changes() {
                    Ok(_) => {
                        self.data_modify = self.data_eeprom.clone();
                        Some(PageAction::SendNotification { text: format!("Map {} undo OK!", self.eeprom_key), kind: ToastKind::Success })
                    },
                    Err(e) => Some(PageAction::SendNotification { text: format!("Map {} undo failed! {}", self.eeprom_key, e), kind: ToastKind::Error })
                }
            }
            if raw_ui.button("Write changes (To RAM)").clicked() {
                return match self.write_to_ram() {
                    Ok(_) => {
                        self.data_memory = self.data_modify.clone();
                        Some(PageAction::SendNotification { text: format!("Map {} RAM write OK!", self.eeprom_key), kind: ToastKind::Success })
                    },
                    Err(e) => Some(PageAction::SendNotification { text: format!("Map {} RAM write failed! {}", self.eeprom_key, e), kind: ToastKind::Error })
                }
            }
        }
        if self.data_memory != self.data_eeprom {
            if raw_ui.button("Write changes (To EEPROM)").clicked() {
                return match self.save_to_eeprom() {
                    Ok(_) => {
                        if let Ok(new_data) = Self::new(self.meta.id, self.ecu_ref.clone(), self.meta.clone()) {
                            *self = new_data;
                        }
                        Some(PageAction::SendNotification { text: format!("Map {} EEPROM save OK!", self.eeprom_key), kind: ToastKind::Success })
                    },
                    Err(e) => Some(PageAction::SendNotification { text: format!("Map {} EEPROM save failed! {}", self.eeprom_key, e), kind: ToastKind::Error })
                }
            }
        }
        if self.data_modify != self.data_program {
            if raw_ui.button("Reset to flash defaults").clicked() {
                self.data_modify = self.data_program.clone();
            }
        }
        None
    }
}

#[derive(Debug, Clone)]
pub struct MapData {
    id: u8,
    name: &'static str,
    x_unit: &'static str,
    y_unit: &'static str,
    x_desc: &'static str,
    y_desc: &'static str,
    v_desc: &'static str,
    value_unit: &'static str,
    x_replace: Option<&'static [&'static str]>,
    y_replace: Option<&'static [&'static str]>,
    show_help: bool
}

impl MapData {
    pub const fn new(
        id: u8,
        name: &'static str,
        x_unit: &'static str,
        y_unit: &'static str,
        x_desc: &'static str,
        y_desc: &'static str,
        v_desc: &'static str,
        value_unit: &'static str,
        x_replace: Option<&'static [&'static str]>,
        y_replace: Option<&'static [&'static str]>
    ) -> Self {
        Self {
            id,
            name,
            x_unit,
            y_unit,
            x_desc,
            y_desc,
            v_desc,
            value_unit,
            x_replace,
            y_replace,
            show_help: false
        }
    }
}

pub struct MapEditor {
    bar: MainStatusBar,
    server: Arc<Mutex<Kwp2000DiagnosticServer>>,
    loaded_maps: HashMap<String, Map>,
    error: Option<String>,
}

impl MapEditor {
    pub fn new(server: Arc<Mutex<Kwp2000DiagnosticServer>>, bar: MainStatusBar) -> Self {
        server.lock().unwrap().set_diagnostic_session_mode(SessionType::ExtendedDiagnostics);
        Self {
            bar,
            server,
            loaded_maps: HashMap::new(),
            error: None,
        }
    }
}

impl super::InterfacePage for MapEditor {
    fn make_ui(
        &mut self,
        ui: &mut eframe::egui::Ui,
        frame: &eframe::Frame,
    ) -> crate::window::PageAction {
        for map in MAP_ARRAY {
            if ui.button(map.name).clicked() {
                self.error = None;
                match Map::new(map.id, self.server.clone(), map.clone()) {
                    Ok(m) => {
                        // Only if map is not already loaded
                        if !self.loaded_maps.contains_key(&m.eeprom_key) {
                            self.loaded_maps.insert(m.eeprom_key.clone(), m);
                        }
                    }
                    Err(e) => self.error = Some(e.to_string()),
                }
            }
        }

        let mut remove_list: Vec<String> = Vec::new();
        let mut action = None;
        for (key, map) in self.loaded_maps.iter_mut() {
            let mut open = true;
            egui::Window::new(map.meta.name)
                .auto_sized()
                .collapsible(true)
                .open(&mut open)
                .vscroll(false)
                .default_size(vec2(800.0, 400.0))
                .show(ui.ctx(), |window| {
                    action = map.generate_window_ui(window);
                });
            if !open {
                remove_list.push(key.clone())
            }
        }
        for key in remove_list {
            self.loaded_maps.remove(&key);
        }
        if let Some(act) = action {
            return act;
        }
        PageAction::None
    }

    fn get_title(&self) -> &'static str {
        "Map editor"
    }

    fn get_status_bar(&self) -> Option<Box<dyn crate::window::StatusBar>> {
        Some(Box::new(self.bar.clone()))
    }
}