use crate::app_state::{self, PersistedGuiState, SessionLogConfig};
use std::path::PathBuf;
use std::sync::mpsc;
use std::time::{Duration, Instant};

use crate::buffers::{HexBuffer, PlotBuffer, TextBuffer};
use crate::logging::{self, LogWriter};
use crate::panels::{config, console, hex_view, plot_view, sidebar};
use crate::perf::{DrainStats, GuiProfiler, GuiSnapshot};
use crate::shortcuts::{self, default_bindings};
use crate::ui_fonts::{self, FontCandidate, FontChoice, UiFontSettings};
use egui::{Color32, Layout, Panel, Pos2, Rect, TextEdit, UiBuilder};
use pipeview_client::SessionManager;
use pipeview_client::config::SessionConfig;
use pipeview_client::session::SessionEvent;
use pipeview_core::protocol::DecodedData;
use pipeview_core::transport::TransportConfig;

const DATA_REPAINT_INTERVAL: Duration = Duration::from_millis(33);

#[derive(Clone)]
pub enum ConnectionStatus {
    Connected,
    Disconnected,
    Connecting,
    Error(String),
}

impl ConnectionStatus {
    fn badge(&self) -> (&'static str, &'static str) {
        match self {
            Self::Connected => ("[connected]", "Connected"),
            Self::Disconnected => ("[disconnected]", "Disconnected"),
            Self::Connecting => ("[connecting]", "Connecting"),
            Self::Error(_) => ("[error]", "Error"),
        }
    }
}

#[derive(Clone, Copy, PartialEq)]
pub enum View {
    Text,
    Hex,
    Plot,
}

#[derive(Clone, Copy, PartialEq)]
pub enum SendMode {
    Text,
    Hex,
}

#[derive(Clone, Copy, PartialEq)]
#[allow(clippy::upper_case_acronyms)]
pub enum LineEnding {
    None,
    LF,
    CR,
    CRLF,
}

impl std::fmt::Display for LineEnding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::None => write!(f, "None"),
            Self::LF => write!(f, "LF (\\n)"),
            Self::CR => write!(f, "CR (\\r)"),
            Self::CRLF => write!(f, "CRLF (\\r\\n)"),
        }
    }
}

#[derive(Clone, Copy)]
pub struct DisplayOptions {
    pub show_timestamp: bool,
    pub show_direction: bool,
    pub show_pipeline: bool,
}

#[derive(Clone, Default)]
pub struct SearchState {
    pub query: String,
    pub matches: Vec<usize>,
    pub current_match: usize,
    pub case_sensitive: bool,
    pub active: bool,
    pub just_opened: bool,
}

impl SearchState {
    pub fn clear(&mut self) {
        self.query.clear();
        self.matches.clear();
        self.current_match = 0;
        self.active = false;
        self.just_opened = false;
    }

    pub fn next(&mut self) {
        if !self.matches.is_empty() {
            self.current_match = (self.current_match + 1) % self.matches.len();
        }
    }

    pub fn prev(&mut self) {
        if !self.matches.is_empty() {
            self.current_match = if self.current_match == 0 {
                self.matches.len() - 1
            } else {
                self.current_match - 1
            };
        }
    }

    // pub fn current_line_index(&self) -> Option<usize> {
        // self.matches.get(self.current_match).copied()
    // }

    pub fn match_count(&self) -> usize {
        self.matches.len()
    }

    pub fn current_display(&self) -> usize {
        if self.matches.is_empty() {
            0
        } else {
            self.current_match + 1
        }
    }
}

pub struct SessionTab {
    pub id: u64,
    pub session_config: SessionConfig,
    pub status: ConnectionStatus,
    pub console: TextBuffer,
    pub hex: HexBuffer,
    pub plot: PlotBuffer,
    pub plot_view: plot_view::PlotViewState,
    pub view: View,
    pub auto_reconnect: bool,
    pub dtr: bool,
    pub rts: bool,
    pub send_input: String,
    pub send_mode: SendMode,
    pub line_ending: LineEnding,
    pub send_status: Option<String>,
    pub search: SearchState,
    pub log_enabled: bool,
    pub log_path: String,
    pub log_writer: Option<LogWriter>,
}

pub struct XserialApp {
    manager: SessionManager,
    tabs: Vec<SessionTab>,
    active: usize,
    display: DisplayOptions,
    font_settings_open: bool,
    font_candidates: Vec<FontCandidate>,
    font_settings: UiFontSettings,
    primary_font_search: String,
    fallback_font_search: String,
    primary_filtered_fonts: Vec<usize>,
    fallback_filtered_fonts: Vec<usize>,
    primary_filter_cache_key: String,
    fallback_filter_cache_key: String,
    config_open: bool,
    config_target: Option<u64>,
    config_form: config::ConfigForm,
    event_rx: mpsc::Receiver<SessionEvent>,
    pending: Vec<SessionEvent>,
    profiler: GuiProfiler,
    shortcut_bindings: Vec<(shortcuts::Action, egui::KeyboardShortcut)>,
}

impl XserialApp {
    pub fn new(
        manager: SessionManager,
        mut rx: tokio::sync::broadcast::Receiver<SessionEvent>,
        ctx: egui::Context,
    ) -> Self {
        let profiler = GuiProfiler::from_env();
        let repaint_counter = profiler.repaint_counter();
        let (event_tx, event_rx) = mpsc::channel();
        let repaint_ctx = ctx.clone();
        tokio::spawn(async move {
            let mut last_repaint = Instant::now()
                .checked_sub(DATA_REPAINT_INTERVAL)
                .unwrap_or_else(Instant::now);
            let mut delayed_repaint_pending = false;
            loop {
                match rx.recv().await {
                    Ok(event) => {
                        if event_tx.send(event).is_err() {
                            break;
                        }
                        let elapsed = last_repaint.elapsed();
                        if elapsed >= DATA_REPAINT_INTERVAL {
                            repaint_counter.increment();
                            repaint_ctx.request_repaint();
                            last_repaint = Instant::now();
                            delayed_repaint_pending = false;
                        } else if !delayed_repaint_pending {
                            repaint_counter.increment();
                            repaint_ctx.request_repaint_after(DATA_REPAINT_INTERVAL - elapsed);
                            delayed_repaint_pending = true;
                        }
                    }
                    Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue,
                    Err(tokio::sync::broadcast::error::RecvError::Closed) => break,
                }
            }
        });

        let font_candidates = ui_fonts::discover_font_candidates();
        let font_settings = ui_fonts::load_font_settings();
        ui_fonts::apply_font_settings(&ctx, &font_settings, &font_candidates);
        let saved_state = app_state::load_gui_state();

        let mut app = Self {
            manager,
            tabs: Vec::new(),
            active: 0,
            display: DisplayOptions {
                show_timestamp: saved_state.show_timestamp,
                show_direction: saved_state.show_direction,
                show_pipeline: saved_state.show_pipeline,
            },
            font_settings_open: false,
            font_candidates,
            font_settings,
            primary_font_search: String::new(),
            fallback_font_search: String::new(),
            primary_filtered_fonts: Vec::new(),
            fallback_filtered_fonts: Vec::new(),
            primary_filter_cache_key: String::from("\0"),
            fallback_filter_cache_key: String::from("\0"),
            config_open: false,
            config_target: None,
            config_form: config::ConfigForm::default(),
            event_rx,
            pending: Vec::new(),
            profiler,
            shortcut_bindings: default_bindings(),
        };
        app.restore_saved_sessions(saved_state);
        app
    }

    fn execute(&mut self, action: shortcuts::Action) {
        use shortcuts::Action::*;

        match action {
            NextTab => {
                if self.tabs.len() > 1 {
                    self.active = (self.active + 1) % self.tabs.len();
                    self.persist_gui_state();
                }
            }
            PrevTab => {
                if self.tabs.len() > 1 {
                    self.active = if self.active == 0 {
                        self.tabs.len() - 1
                    } else {
                        self.active - 1
                    };
                    self.persist_gui_state();
                }
            }
            ViewText => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    tab.view = View::Text;
                }
            }
            ViewHex => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    tab.view = View::Hex;
                }
            }
            ViewPlot => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    tab.view = View::Plot;
                }
            }
            NewSession => self.open_create_config(),
            EditSession => {
                if let Some(tab) = self.tabs.get(self.active) {
                    self.open_edit_config(tab.id);
                }
            }
            DeleteSession => {
                if !self.tabs.is_empty() {
                    let id = self.tabs[self.active].id;
                    self.manager.remove(id);
                    self.tabs.remove(self.active);
                    if self.active >= self.tabs.len() && !self.tabs.is_empty() {
                        self.active = self.tabs.len() - 1;
                    }
                    self.persist_gui_state();
                }
            }
            ToggleConnect => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    let connected = matches!(
                        tab.status,
                        ConnectionStatus::Connected | ConnectionStatus::Connecting
                    );
                    if let Some(handle) = self.manager.get(tab.id) {
                        if connected {
                            tab.status = ConnectionStatus::Disconnected;
                            let handle = handle.clone();
                            tokio::spawn(async move {
                                let _ = handle.disconnect().await;
                            });
                        } else {
                            tab.status = ConnectionStatus::Connecting;
                            let handle = handle.clone();
                            tokio::spawn(async move {
                                let _ = handle.connect().await;
                            });
                        }
                    } else {
                        tab.status = ConnectionStatus::Error(String::from("session not found"));
                    }
                }
            }
            Clear => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    tab.console.clear();
                    tab.hex.clear();
                    tab.plot.clear();
                    tab.send_status = Some(String::from("Cleared"));
                }
            }
            UiSettings => self.font_settings_open = true,
            CloseOverlay => {
                self.config_open = false;
                self.font_settings_open = false;
            }
            Search => {
                if let Some(tab) = self.tabs.get_mut(self.active) {
                    tab.search.active = true;
                    tab.search.just_opened = true;
                }
            }
            SearchNext => {
                if let Some(tab) = self.tabs.get_mut(self.active)
                    && tab.search.active
                {
                    tab.search.next();
                }
            }
            SearchPrev => {
                if let Some(tab) = self.tabs.get_mut(self.active)
                    && tab.search.active
                {
                    tab.search.prev();
                }
            }
        }
    }

    fn open_create_config(&mut self) {
        self.config_target = None;
        self.config_form = config::ConfigForm::default();
        self.config_open = true;
    }

    fn restore_saved_sessions(&mut self, saved_state: PersistedGuiState) {
        for (i, session_config) in saved_state.sessions.into_iter().enumerate() {
            self.add_session_tab(session_config);
            if let Some(tab) = self.tabs.last_mut()
                && let Some(log_cfg) = saved_state.sessions_log.get(i)
            {
                tab.log_enabled = log_cfg.enabled;
                tab.log_path = log_cfg.file_path.clone();
                if log_cfg.enabled && !log_cfg.file_path.is_empty() {
                    tab.log_writer = LogWriter::open(&log_cfg.file_path).ok();
                }
            }
        }
        if !self.tabs.is_empty() {
            self.active = saved_state.active.min(self.tabs.len() - 1);
        }
    }

    fn add_session_tab(&mut self, session_config: SessionConfig) {
        let history_limit = session_config.history_limit;
        let auto_reconnect = session_config.auto_reconnect;
        let (dtr, rts) = match &session_config.transport {
            TransportConfig::Serial { dtr, rts, .. } => (*dtr, *rts),
            _ => (false, false),
        };
        let handle = self.manager.create(session_config.clone());
        self.tabs.push(SessionTab {
            id: handle.id(),
            session_config,
            status: ConnectionStatus::Connecting,
            console: TextBuffer::new(history_limit),
            hex: HexBuffer::new(history_limit),
            plot: PlotBuffer::new(history_limit),
            plot_view: plot_view::PlotViewState::default(),
            view: View::Text,
            auto_reconnect,
            dtr,
            rts,
            send_input: String::new(),
            send_mode: SendMode::Text,
            line_ending: LineEnding::None,
            send_status: None,
            search: SearchState::default(),
            log_enabled: false,
            log_path: String::new(),
            log_writer: None,
        });
    }

    fn persist_gui_state(&self) {
        app_state::save_gui_state(&PersistedGuiState {
            sessions: self
                .tabs
                .iter()
                .map(|tab| tab.session_config.clone())
                .collect(),
            sessions_log: self
                .tabs
                .iter()
                .map(|tab| SessionLogConfig {
                    enabled: tab.log_enabled,
                    file_path: tab.log_path.clone(),
                })
                .collect(),
            active: if self.tabs.is_empty() {
                0
            } else {
                self.active.min(self.tabs.len() - 1)
            },
            show_timestamp: self.display.show_timestamp,
            show_direction: self.display.show_direction,
            show_pipeline: self.display.show_pipeline,
        });
    }

    fn open_edit_config(&mut self, id: u64) {
        if let Some(tab) = self.tabs.iter().find(|tab| tab.id == id) {
            self.config_target = Some(id);
            self.config_form = config::ConfigForm::from_session_config(&tab.session_config);
            self.config_open = true;
        }
    }

    fn apply_session_config(&mut self, id: u64, session_config: SessionConfig) {
        let handle = self.manager.get(id);
        if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
            let history_limit = session_config.history_limit;
            tab.session_config = session_config.clone();
            tab.auto_reconnect = session_config.auto_reconnect;
            tab.console.set_limit(history_limit);
            tab.hex.set_limit(history_limit);
            tab.plot.set_limit(history_limit);
            tab.status = ConnectionStatus::Connecting;
            tab.send_status = Some(String::from("Session reconfigured"));
        }
        self.persist_gui_state();

        if let Some(handle) = handle {
            tokio::spawn(async move {
                let _ = handle.reconfigure(session_config).await;
            });
        } else if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
            tab.status = ConnectionStatus::Error(String::from("session not found"));
        }
    }

    fn drain_events(&mut self) {
        let started = Instant::now();
        let mut stats = DrainStats {
            drained_events: 0,
            drained_data_events: 0,
            drained_text_events: 0,
            drained_hex_events: 0,
            drained_plot_events: 0,
            pending_events: 0,
        };
        while let Ok(event) = self.event_rx.try_recv() {
            self.pending.push(event);
        }
        stats.pending_events = self.pending.len();

        for event in self.pending.drain(..) {
            stats.drained_events += 1;
            match event {
                SessionEvent::Connected(id) => {
                    if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
                        tab.status = ConnectionStatus::Connected;
                    }
                }
                SessionEvent::Disconnected(id) | SessionEvent::Closed(id) => {
                    if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
                        tab.status = ConnectionStatus::Disconnected;
                    }
                }
                SessionEvent::Error(id, message) => {
                    if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
                        tab.status = ConnectionStatus::Error(message);
                    }
                }
                SessionEvent::Data(id, entry) => {
                    stats.drained_data_events += 1;
                    if let Some(tab) = self.tabs.iter_mut().find(|tab| tab.id == id) {
                        if let Some(ref writer) = tab.log_writer
                            && let Some(line) = logging::format_data_log(
                                &entry,
                                "IN",
                                self.display.show_timestamp,
                                self.display.show_direction,
                                self.display.show_pipeline,
                            )
                        {
                            writer.write_line(&line);
                        }
                        match &entry.data {
                            DecodedData::Text(_) => {
                                stats.drained_text_events += 1;
                                tab.console.push(&entry);
                            }
                            DecodedData::Hex(_) => {
                                stats.drained_hex_events += 1;
                                tab.hex.push(&entry);
                            }
                            DecodedData::Plot(_) => {
                                stats.drained_plot_events += 1;
                                tab.plot.push(&entry);
                            }
                            DecodedData::Binary(_) => {}
                        }
                    }
                }
            }
        }
        self.profiler.record_drain(started.elapsed(), stats);
    }

    fn wants_live_plot_repaint(&self) -> bool {
        self.tabs.iter().enumerate().any(|(index, tab)| {
            matches!(tab.status, ConnectionStatus::Connected)
                && (tab.plot_view.detached
                    || (index == self.active && matches!(tab.view, View::Plot)))
        })
    }

    fn profiler_snapshot(&self) -> GuiSnapshot {
        if let Some(tab) = self.tabs.get(self.active) {
            GuiSnapshot {
                tabs: self.tabs.len(),
                active_view: match tab.view {
                    View::Text => "text",
                    View::Hex => "hex",
                    View::Plot => "plot",
                },
                active_text_lines: tab.console.len(),
                active_hex_lines: tab.hex.len(),
                active_plot_series: tab.plot.series_len(),
                active_plot_points: tab.plot.total_points(),
            }
        } else {
            GuiSnapshot {
                tabs: self.tabs.len(),
                active_view: "none",
                active_text_lines: 0,
                active_hex_lines: 0,
                active_plot_series: 0,
                active_plot_points: 0,
            }
        }
    }

    fn render_config_window(&mut self, ctx: &egui::Context) {
        if !self.config_open {
            return;
        }

        let mut open = self.config_open;
        let title = if self.config_target.is_some() {
            "Edit Session Config"
        } else {
            "Session Config"
        };
        let submit_label = if self.config_target.is_some() {
            "Save Session Config"
        } else {
            "Create Session"
        };
        let mut submitted = None;
        egui::Window::new(title).open(&mut open).show(ctx, |ui| {
            submitted = config::render(ui, &mut self.config_form, submit_label);
        });

        if let Some(session_config) = submitted {
            if let Some(id) = self.config_target {
                self.apply_session_config(id, session_config);
            } else {
                self.add_session_tab(session_config);
                self.active = self.tabs.len() - 1;
                self.persist_gui_state();
            }
            open = false;
        }
        if !open {
            self.config_target = None;
        }
        self.config_open = open;
    }

    fn render_sidebar(&mut self, ui: &mut egui::Ui) {
        let mut on_new = false;
        let mut on_edit = None;
        let mut on_delete = None;
        let previous_active = self.active;

        Panel::left("sidebar")
            .resizable(false)
            .show_inside(ui, |ui| {
                let sessions: Vec<_> = self
                    .tabs
                    .iter()
                    .map(|tab| sidebar::SessionListItem {
                        id: tab.id,
                        status: tab.status.clone(),
                        transport_summary: transport_summary(&tab.session_config.transport),
                    })
                    .collect();
                sidebar::render(
                    ui,
                    &sessions,
                    &mut self.active,
                    &mut on_new,
                    &mut on_edit,
                    &mut on_delete,
                );
            });

        if on_new {
            self.open_create_config();
        }

        if let Some(index) = on_edit
            && let Some(tab) = self.tabs.get(index)
        {
            self.open_edit_config(tab.id);
        }

        if let Some(index) = on_delete {
            if let Some(tab) = self.tabs.get(index) {
                self.manager.remove(tab.id);
            }
            self.tabs.remove(index);
            if self.active >= self.tabs.len() && !self.tabs.is_empty() {
                self.active = self.tabs.len() - 1;
            }
            self.persist_gui_state();
        } else if self.active != previous_active {
            self.persist_gui_state();
        }
    }

    fn render_main_panel(&mut self, ui: &mut egui::Ui) {
        egui::CentralPanel::default().show_inside(ui, |ui| {
            if self.tabs.is_empty() {
                ui.heading("No sessions.");
                return;
            }

            if self.active >= self.tabs.len() {
                self.active = self.tabs.len() - 1;
            }

            let manager = self.manager.clone();
            let display = &mut self.display;
            let mut persist_state = false;
            let mut text_render = None;
            let mut hex_render = None;
            let mut plot_render = None;

            {
                let tab = &mut self.tabs[self.active];
                let (badge, status_text) = tab.status.badge();

                ui.horizontal(|ui| {
                    ui.heading(format!("Session {}", tab.id));
                    ui.label(badge);
                    ui.separator();
                    ui.label(status_text);
                    ui.separator();
                    if ui
                        .selectable_label(tab.view == View::Text, "Text")
                        .clicked()
                    {
                        tab.view = View::Text;
                    }
                    if ui.selectable_label(tab.view == View::Hex, "Hex").clicked() {
                        tab.view = View::Hex;
                    }
                    if ui
                        .selectable_label(tab.view == View::Plot, "Plot")
                        .clicked()
                    {
                        tab.view = View::Plot;
                    }
                });

                let auto_reconnect_changed = render_session_controls(ui, &manager, tab);
                persist_state |= auto_reconnect_changed;

                let mut display_changed = false;
                ui.horizontal_wrapped(|ui| {
                    ui.label("Show:");
                    display_changed |= ui
                        .checkbox(&mut display.show_timestamp, "Timestamp")
                        .changed();
                    display_changed |= ui
                        .checkbox(&mut display.show_direction, "Direction")
                        .changed();
                    display_changed |= ui.checkbox(&mut display.show_pipeline, "Pipe").changed();
                });
                persist_state |= display_changed;

                render_search_bar(ui, tab);

                if let ConnectionStatus::Error(message) = &tab.status {
                    ui.label(egui::RichText::new(message).color(Color32::RED));
                }

                let full = ui.available_rect_before_wrap();
                let send_height = 240.0;
                let separator = 8.0;
                let receive_height = (full.height() - send_height - separator).max(0.0);
                let receive_rect = Rect::from_min_max(
                    full.min,
                    Pos2::new(full.max.x, full.min.y + receive_height),
                );
                let send_rect =
                    Rect::from_min_max(Pos2::new(full.min.x, full.max.y - send_height), full.max);

                ui.scope_builder(
                    UiBuilder::new()
                        .max_rect(receive_rect)
                        .layout(Layout::top_down(egui::Align::Min).with_cross_justify(true)),
                    |ui| {
                        let started = Instant::now();
                        match tab.view {
                            View::Text => {
                                let line_count = console::render(ui, &tab.console, *display, tab.search.active.then_some(&tab.search));
                                text_render = Some((started.elapsed(), line_count));
                            }
                            View::Hex => {
                                let line_count = hex_view::render(ui, &tab.hex, *display, tab.search.active.then_some(&tab.search));
                                hex_render = Some((started.elapsed(), line_count));
                            }
                            View::Plot => {
                                if tab.plot_view.detached {
                                    ui.heading(format!(
                                        "Plot window detached for Session {}",
                                        tab.id
                                    ));
                                    ui.label("The plot is currently shown in a floating window.");
                                    if ui.button("Dock Plot Back").clicked() {
                                        tab.plot_view.detached = false;
                                    }
                                } else {
                                    let output = plot_view::render(
                                        ui,
                                        &mut tab.plot,
                                        tab.id,
                                        &mut tab.plot_view,
                                    );
                                    if output.toggle_detached {
                                        tab.plot_view.detached = true;
                                    }
                                    plot_render = Some((started.elapsed(), output.stats));
                                }
                            }
                        }
                    },
                );

                ui.scope_builder(
                    UiBuilder::new()
                        .max_rect(send_rect)
                        .layout(Layout::top_down(egui::Align::Min).with_cross_justify(true)),
                    |ui| render_send_panel(ui, &manager, tab),
                );
            }

            if let Some((elapsed, line_count)) = text_render {
                self.profiler.record_text_render(elapsed, line_count);
            }
            if let Some((elapsed, line_count)) = hex_render {
                self.profiler.record_hex_render(elapsed, line_count);
            }
            if let Some((elapsed, stats)) = plot_render {
                self.profiler.record_plot_render(elapsed, stats);
            }
            if persist_state {
                self.persist_gui_state();
            }
        });
    }

    fn render_detached_plot_windows(&mut self, ctx: &egui::Context) {
        let mut plot_renders = Vec::new();

        for tab in &mut self.tabs {
            if !tab.plot_view.detached {
                continue;
            }

            let mut open = true;
            let mut output = None;
            egui::Window::new(format!("Plot - Session {}", tab.id))
                .open(&mut open)
                .default_width(720.0)
                .default_height(480.0)
                .resizable(true)
                .vscroll(false)
                .show(ctx, |ui| {
                    let started = Instant::now();
                    let render_output =
                        plot_view::render(ui, &mut tab.plot, tab.id, &mut tab.plot_view);
                    output = Some((started.elapsed(), render_output));
                });

            if let Some((elapsed, render_output)) = output {
                if render_output.toggle_detached {
                    tab.plot_view.detached = false;
                }
                plot_renders.push((elapsed, render_output.stats));
            }

            if !open {
                tab.plot_view.detached = false;
            }
        }

        for (elapsed, stats) in plot_renders {
            self.profiler.record_plot_render(elapsed, stats);
        }
    }

    fn render_top_bar(&mut self, ui: &mut egui::Ui) {
        Panel::top("top_bar").show_inside(ui, |ui| {
            ui.horizontal_wrapped(|ui| {
                ui.heading("pipeview");
                ui.separator();
                // ui.label(format!(
                //     "Fonts: {} + {}  {:.1} pt",
                //     ui_fonts::font_choice_label(
                //         &self.font_settings.primary_choice,
                //         &self.font_candidates
                //     ),
                //     ui_fonts::font_choice_label(
                //         &self.font_settings.fallback_choice,
                //         &self.font_candidates
                //     ),
                //     self.font_settings.ui_font_size
                // ));
                if ui.button("UI Settings").clicked() {
                    self.font_settings_open = true;
                }
            });
        });
    }

    fn render_font_settings_window(&mut self, ctx: &egui::Context) {
        if !self.font_settings_open {
            return;
        }

        let mut open = self.font_settings_open;
        let mut changed = false;
        egui::Window::new("UI Settings")
            .open(&mut open)
            .default_width(520.0)
            .resizable(true)
            .show(ctx, |ui| {
                ui.heading("Fonts");
                ui.horizontal(|ui| {
                    ui.label("Primary:");
                    ui.monospace(ui_fonts::font_choice_label(
                        &self.font_settings.primary_choice,
                        &self.font_candidates,
                    ));
                    ui.label("Fallback:");
                    ui.monospace(ui_fonts::font_choice_label(
                        &self.font_settings.fallback_choice,
                        &self.font_candidates,
                    ));
                    if ui.button("Refresh").clicked() {
                        self.font_candidates = ui_fonts::discover_font_candidates();
                        self.invalidate_font_filters();
                    }
                });
                ui.small("Primary font is tried first. Fallback font is used when the primary font lacks a glyph.");
                ui.add_space(6.0);
                render_font_selector(
                    ui,
                    "Primary font",
                    "primary_font_choice",
                    &mut self.font_settings.primary_choice,
                    &mut self.primary_font_search,
                    &self.font_candidates,
                    &mut self.primary_filtered_fonts,
                    &mut self.primary_filter_cache_key,
                    true,
                    true,
                    180.0,
                    &mut changed,
                );
                ui.separator();
                render_font_selector(
                    ui,
                    "Fallback font",
                    "fallback_font_choice",
                    &mut self.font_settings.fallback_choice,
                    &mut self.fallback_font_search,
                    &self.font_candidates,
                    &mut self.fallback_filtered_fonts,
                    &mut self.fallback_filter_cache_key,
                    true,
                    true,
                    140.0,
                    &mut changed,
                );
                ui.separator();
                ui.heading("Sizes");
                ui.label("UI font size");
                changed |= ui
                    .add(
                        egui::Slider::new(&mut self.font_settings.ui_font_size, 10.0..=28.0)
                            .suffix(" pt"),
                    )
                    .changed();
                ui.label("Monospace font size");
                changed |= ui
                    .add(
                        egui::Slider::new(
                            &mut self.font_settings.monospace_font_size,
                            10.0..=28.0,
                        )
                        .suffix(" pt"),
                    )
                    .changed();
                ui.label("Heading size");
                changed |= ui
                    .add(
                        egui::Slider::new(&mut self.font_settings.heading_font_size, 14.0..=40.0)
                            .suffix(" pt"),
                    )
                    .changed();
                ui.separator();
                ui.heading("Preview");
                ui.label("The quick brown fox jumps over the lazy dog.");
                ui.label("中文预览：串口、网络、绘图、十六进制、会话管理。");
                ui.monospace("Monospace preview: 0123456789 ABCDEF deadbeef");
            });

        if changed {
            ui_fonts::apply_font_settings(ctx, &self.font_settings, &self.font_candidates);
            ui_fonts::save_font_settings(&self.font_settings);
        }
        self.font_settings_open = open;
    }

    fn invalidate_font_filters(&mut self) {
        self.primary_filtered_fonts.clear();
        self.fallback_filtered_fonts.clear();
        self.primary_filter_cache_key = String::from("\0");
        self.fallback_filter_cache_key = String::from("\0");
    }
}

fn transport_summary(transport: &TransportConfig) -> String {
    match transport {
        TransportConfig::Serial { port, .. } => format!("Serial {}", port),
        TransportConfig::Tcp { addr } => format!("TCP {}", addr),
        TransportConfig::Udp {
            bind_addr,
            remote_addr,
        } => match remote_addr {
            Some(remote_addr) => format!("UDP {} -> {}", bind_addr, remote_addr),
            None => format!("UDP {}", bind_addr),
        },
    }
}

#[allow(clippy::too_many_arguments)]
fn render_font_selector(
    ui: &mut egui::Ui,
    title: &str,
    id_prefix: &str,
    choice: &mut FontChoice,
    search: &mut String,
    candidates: &[FontCandidate],
    filtered: &mut Vec<usize>,
    cache_key: &mut String,
    allow_auto: bool,
    allow_default: bool,
    max_height: f32,
    changed: &mut bool,
) {
    ui.label(title);
    ui.horizontal(|ui| {
        ui.label("Search:");
        ui.text_edit_singleline(search);
    });
    ui.horizontal_wrapped(|ui| {
        if allow_auto {
            *changed |= ui
                .selectable_value(choice, FontChoice::Auto, "Auto")
                .changed();
        }
        if allow_default {
            *changed |= ui
                .selectable_value(choice, FontChoice::Default, "Default")
                .changed();
        }
    });
    ui.add_space(4.0);
    refresh_font_filter(search, candidates, filtered, cache_key);
    ui.small(format!("{} fonts", filtered.len()));
    let row_height = ui.spacing().interact_size.y;
    egui::ScrollArea::vertical()
        .id_salt(format!("{id_prefix}_scroll"))
        .max_height(max_height)
        .auto_shrink([false, false])
        .show_rows(ui, row_height, filtered.len(), |ui, row_range| {
            for row in row_range {
                if let Some(candidate) = filtered.get(row).and_then(|index| candidates.get(*index))
                {
                    let response = ui.selectable_value(
                        choice,
                        FontChoice::System(candidate.id.clone()),
                        candidate.display_label.as_str(),
                    );
                    *changed |= response.changed();
                    response.on_hover_text(&candidate.path);
                }
            }
        });
}

fn refresh_font_filter(
    search: &str,
    candidates: &[FontCandidate],
    filtered: &mut Vec<usize>,
    cache_key: &mut String,
) {
    let needle = search.trim().to_lowercase();
    if *cache_key == needle {
        return;
    }

    filtered.clear();
    if needle.is_empty() {
        filtered.extend(0..candidates.len());
    } else {
        filtered.extend(
            candidates
                .iter()
                .enumerate()
                .filter(|(_, candidate)| candidate.search_key.contains(&needle))
                .map(|(index, _)| index),
        );
    }
    *cache_key = needle;
}

impl eframe::App for XserialApp {
    fn update(&mut self, _ctx: &egui::Context, _frame: &mut eframe::Frame) {}

    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
        {
            let supress = ui.ctx().egui_wants_keyboard_input();
            let actions = shortcuts::process(ui.ctx(), supress, &self.shortcut_bindings);

            for action in actions {
                self.execute(action);
            }
        }

        let frame_started = Instant::now();
        self.drain_events();
        if self.wants_live_plot_repaint() {
            ui.ctx().request_repaint_after(Duration::from_millis(16));
        }
        self.render_top_bar(ui);
        self.render_font_settings_window(ui.ctx());
        self.render_config_window(ui.ctx());
        self.render_sidebar(ui);
        self.render_main_panel(ui);
        self.render_detached_plot_windows(ui.ctx());
        self.profiler
            .record_frame(frame_started.elapsed(), self.profiler_snapshot());
    }
}

fn render_search_bar(ui: &mut egui::Ui, tab: &mut SessionTab) {
    if !tab.search.active {
        return;
    }
    ui.horizontal(|ui| {
        let response = ui.add(
            TextEdit::singleline(&mut tab.search.query)
                .hint_text("Search...")
                .desired_width(200.0),
        );
        if tab.search.just_opened {
            response.request_focus();
            tab.search.just_opened = false;
        }
        if response.changed() {
            let matches = match tab.view {
                View::Text => tab.console.search(&tab.search.query, tab.search.case_sensitive),
                View::Hex => tab.hex.search(&tab.search.query, tab.search.case_sensitive),
                View::Plot => Vec::new(),
            };
            tab.search.matches = matches;
            tab.search.current_match = 0;
        }
        if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
            tab.search.next();
        }

        ui.label(format!(
            "{}/{}",
            tab.search.current_display(),
            tab.search.match_count()
        ));

        if ui.button("▲").clicked() {
            tab.search.prev();
        }
        if ui.button("▼").clicked() {
            tab.search.next();
        }

        if ui.checkbox(&mut tab.search.case_sensitive, "Aa").changed() {
            let matches = match tab.view {
                View::Text => tab.console.search(&tab.search.query, tab.search.case_sensitive),
                View::Hex => tab.hex.search(&tab.search.query, tab.search.case_sensitive),
                View::Plot => Vec::new(),
            };
            tab.search.matches = matches;
            tab.search.current_match = 0;
        }

        if ui.button("✕").clicked() {
            tab.search.clear();
        }
    });
}

fn render_session_controls(
    ui: &mut egui::Ui,
    manager: &SessionManager,
    tab: &mut SessionTab,
) -> bool {
    let mut auto_reconnect_changed = false;
    ui.horizontal_wrapped(|ui| {
        let connected = matches!(
            tab.status,
            ConnectionStatus::Connected | ConnectionStatus::Connecting
        );
        let connect_label = if connected { "Disconnect" } else { "Connect" };
        if ui.button(connect_label).clicked() {
            if let Some(handle) = manager.get(tab.id) {
                if connected {
                    tab.status = ConnectionStatus::Disconnected;
                    tokio::spawn(async move {
                        let _ = handle.disconnect().await;
                    });
                } else {
                    tab.status = ConnectionStatus::Connecting;
                    tokio::spawn(async move {
                        let _ = handle.connect().await;
                    });
                }
            } else {
                tab.status = ConnectionStatus::Error(String::from("session not found"));
            }
        }

        // if ui.button("Reconnect").clicked() {
        //     if let Some(handle) = manager.get(tab.id) {
        //         tab.status = ConnectionStatus::Connecting;
        //         tokio::spawn(async move {
        //             let _ = handle.reconnect().await;
        //         });
        //     } else {
        //         tab.status = ConnectionStatus::Error(String::from("session not found"));
        //     }
        // }

        if ui.button("Clear").clicked() {
            tab.console.clear();
            tab.hex.clear();
            tab.plot.clear();
            tab.send_status = Some(String::from("Cleared"));
        }

        let response = ui.checkbox(&mut tab.auto_reconnect, "Auto reconnect");
        if response.changed() {
            tab.session_config.auto_reconnect = tab.auto_reconnect;
            auto_reconnect_changed = true;
            if let Some(handle) = manager.get(tab.id) {
                let enabled = tab.auto_reconnect;
                tokio::spawn(async move {
                    let _ = handle.set_auto_reconnect(enabled).await;
                });
            } else {
                tab.status = ConnectionStatus::Error(String::from("session not found"));
            }
        }
        if matches!(tab.status, ConnectionStatus::Connected)
            && matches!(tab.session_config.transport, TransportConfig::Serial { .. })
        {
            let dtr_changed = ui.checkbox(&mut tab.dtr, "DTR").changed();
            let rts_changed = ui.checkbox(&mut tab.rts, "RTS").changed();
            if dtr_changed || rts_changed {
                if let Some(handle) = manager.get(tab.id) {
                    let dtr = tab.dtr;
                    let rts = tab.rts;
                    tokio::spawn(async move {
                        if dtr_changed {
                            let _ = handle.set_dtr(dtr).await;
                        }
                        if rts_changed {
                            let _ = handle.set_rts(rts).await;
                        }
                    });
                } else {
                    tab.status = ConnectionStatus::Error(String::from("session not found"));
                }
            }
        }
    });
    auto_reconnect_changed
}

fn render_send_panel(ui: &mut egui::Ui, manager: &SessionManager, tab: &mut SessionTab) {
    ui.set_width(ui.available_width());
    ui.heading("Send");
    ui.horizontal(|ui| {
        ui.selectable_value(&mut tab.send_mode, SendMode::Text, "Text");
        ui.selectable_value(&mut tab.send_mode, SendMode::Hex, "Hex");
        if tab.send_mode == SendMode::Text {
            ui.add_space(6.0);
            egui::ComboBox::from_label("Line ending")
                .selected_text(tab.line_ending.to_string())
                .show_ui(ui, |ui| {
                    ui.selectable_value(
                        &mut tab.line_ending,
                        LineEnding::None,
                        LineEnding::None.to_string(),
                    );
                    ui.selectable_value(
                        &mut tab.line_ending,
                        LineEnding::LF,
                        LineEnding::LF.to_string(),
                    );
                    ui.selectable_value(
                        &mut tab.line_ending,
                        LineEnding::CR,
                        LineEnding::CR.to_string(),
                    );
                    ui.selectable_value(
                        &mut tab.line_ending,
                        LineEnding::CRLF,
                        LineEnding::CRLF.to_string(),
                    );
                });
        }
    });
    ui.add_space(6.0);

    let log_toggled = ui
        .checkbox(&mut tab.log_enabled, "Log to file")
        .changed();
    if log_toggled {
        if tab.log_enabled {
            tab.log_path = default_log_path(tab.id)
                .to_string_lossy()
                .to_string();
            tab.log_writer = LogWriter::open(&tab.log_path).ok();
        } else {
            tab.log_writer = None;
        }
    }
    if tab.log_enabled {
        ui.horizontal(|ui| {
            let changed = ui
                .text_edit_singleline(&mut tab.log_path)
                .lost_focus();
            if changed && !tab.log_path.is_empty() {
                tab.log_writer = LogWriter::open(&tab.log_path).ok();
            }
        });
    }
    ui.add_space(3.0);

    let hint = match tab.send_mode {
        SendMode::Text => "Enter text to send",
        SendMode::Hex => "Enter hex bytes, e.g. 48 65 6C 6C 6F",
    };
    let response = ui.add(
        TextEdit::multiline(&mut tab.send_input)
            .desired_rows(6)
            .desired_width(f32::INFINITY)
            .hint_text(hint),
    );

    let wants_submit = response.has_focus()
        && ui.input(|input| input.key_pressed(egui::Key::Enter) && input.modifiers.command_only());

    let mut send_clicked = false;
    ui.horizontal(|ui| {
        send_clicked = ui.button("Send").clicked();
        if let Some(status) = &tab.send_status {
            ui.label(
                egui::RichText::new(status).color(if status.starts_with("Send failed") {
                    Color32::RED
                } else {
                    Color32::GRAY
                }),
            );
        }
    });

    if !(send_clicked || wants_submit) {
        return;
    }

    match build_payload(tab) {
        Ok(Some(payload)) => {
            if let Some(handle) = manager.get(tab.id) {
                match tab.send_mode {
                    SendMode::Text => {
                        let mut text = tab.send_input.trim_end_matches('\n').to_string();
                        if !text.is_empty() {
                            match tab.line_ending {
                                LineEnding::None => {}
                                LineEnding::LF => text.push('\n'),
                                LineEnding::CR => text.push('\r'),
                                LineEnding::CRLF => text.push_str("\r\n"),
                            }
                            tab.console.push_outbound(text.clone());
                            if let Some(ref writer) = tab.log_writer {
                                writer.write_line(&logging::format_sent_log(&text));
                            }
                        }
                    }
                    SendMode::Hex => {
                        let hex = tab
                            .send_input
                            .split_whitespace()
                            .collect::<Vec<_>>()
                            .join(" ");
                        if !hex.is_empty() {
                            tab.hex.push_outbound(hex.clone());
                            if let Some(ref writer) = tab.log_writer {
                                writer.write_line(&logging::format_sent_log(&hex));
                            }
                        }
                    }
                }
                tokio::spawn(async move {
                    let _ = handle.send(payload).await;
                });
                tab.send_input.clear();
                tab.send_status = Some(String::from("Sent"));
            } else {
                tab.send_status = Some(String::from("Send failed: session not found"));
            }
        }
        Ok(None) => {
            tab.send_status = Some(String::from("Nothing to send"));
        }
        Err(message) => {
            tab.send_status = Some(format!("Send failed: {message}"));
        }
    }
}

fn default_log_path(session_id: u64) -> PathBuf {
    use std::time::{SystemTime, UNIX_EPOCH};
    let dir = app_state::config_dir().join("logs");
    let ts = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();
    dir.join(format!("session_{session_id}_{ts}.log"))
}

fn build_payload(tab: &SessionTab) -> Result<Option<Vec<u8>>, String> {
    let trimmed = tab.send_input.trim();
    if trimmed.is_empty() {
        return Ok(None);
    }

    match tab.send_mode {
        SendMode::Text => {
            let mut text = tab.send_input.trim_end_matches('\n').to_string();
            match tab.line_ending {
                LineEnding::None => {}
                LineEnding::LF => text.push('\n'),
                LineEnding::CR => text.push('\r'),
                LineEnding::CRLF => text.push_str("\r\n"),
            }
            Ok(Some(text.into_bytes()))
        }
        SendMode::Hex => {
            let compact: String = trimmed
                .chars()
                .filter(|ch| !ch.is_ascii_whitespace())
                .collect();
            hex::decode(compact)
                .map(Some)
                .map_err(|err| format!("invalid hex input ({err})"))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::transport_summary;
    use pipeview_core::transport::TransportConfig;
    use pipeview_core::transport::serial::{
        SerialDataBits, SerialFlowControl, SerialParity, SerialStopBits,
    };

    #[test]
    fn transport_summary_formats_tcp_and_serial() {
        assert_eq!(
            transport_summary(&TransportConfig::Tcp {
                addr: String::from("127.0.0.1:8080"),
            }),
            "TCP 127.0.0.1:8080"
        );

        assert_eq!(
            transport_summary(&TransportConfig::Serial {
                port: String::from("COM7"),
                baud_rate: 115200,
                data_bits: SerialDataBits::Eight,
                parity: SerialParity::None,
                stop_bits: SerialStopBits::One,
                flow_control: SerialFlowControl::None,
                dtr: false,
                rts: false,
            }),
            "Serial COM7"
        );
    }

    #[test]
    fn transport_summary_formats_udp() {
        assert_eq!(
            transport_summary(&TransportConfig::Udp {
                bind_addr: String::from("0.0.0.0:9000"),
                remote_addr: Some(String::from("127.0.0.1:9001")),
            }),
            "UDP 0.0.0.0:9000 -> 127.0.0.1:9001"
        );

        assert_eq!(
            transport_summary(&TransportConfig::Udp {
                bind_addr: String::from("127.0.0.1:0"),
                remote_addr: None,
            }),
            "UDP 127.0.0.1:0"
        );
    }
}