//! Main UI layout.

use ratatui::{
    layout::{Alignment, Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Clear, Paragraph, Wrap},
    Frame,
};

use crate::app::{App, InputMode, RadioState};

use super::captures_list::render_captures_list;
use super::command::render_command_line;
use super::settings_menu::{render_settings_dropdown, render_settings_tabs};
use super::signal_menu::render_signal_menu;
use super::status_bar::render_status_bar;

use crate::app::InputMode as IM;

const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Draw the entire UI
pub fn draw_ui(frame: &mut Frame, app: &App) {
    let show_settings = matches!(app.input_mode, IM::SettingsSelect | IM::SettingsEdit);
    let show_command = app.input_mode == IM::Command;

    let mut constraints = vec![Constraint::Length(3)]; // Header

    if show_settings {
        constraints.push(Constraint::Length(3)); // Settings tabs
    }

    constraints.push(Constraint::Min(8)); // Captures list
    constraints.push(Constraint::Length(3)); // Status bar

    if show_command {
        constraints.push(Constraint::Length(3)); // Command input
    }

    constraints.push(Constraint::Length(1)); // Help bar

    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .constraints(constraints)
        .split(frame.area());

    let mut idx = 0;
    render_header(frame, chunks[idx], app);
    idx += 1;

    if show_settings {
        render_settings_tabs(frame, chunks[idx], app);
        idx += 1;
    }

    render_captures_list(frame, chunks[idx], app);
    idx += 1;

    render_status_bar(frame, chunks[idx], app);
    idx += 1;

    if show_command {
        render_command_line(frame, chunks[idx], app);
        idx += 1;
    }

    render_help_bar(frame, chunks[idx], app);

    // Overlay widgets (rendered on top of everything else)
    if app.input_mode == InputMode::SignalMenu {
        render_signal_menu(frame, app);
    }

    if app.input_mode == InputMode::SettingsEdit {
        render_settings_dropdown(frame, app);
    }

    if app.input_mode == InputMode::StartupImport {
        render_startup_import_prompt(frame, app);
    }

    if matches!(
        app.input_mode,
        InputMode::ExportFilename
            | InputMode::FobMetaYear
            | InputMode::FobMetaMake
            | InputMode::FobMetaModel
            | InputMode::FobMetaRegion
            | InputMode::FobMetaNotes
    ) {
        render_export_form(frame, app);
    }
}

/// Render the header with title and radio status
fn render_header(frame: &mut Frame, area: Rect, app: &App) {
    let (status_symbol, status_style) = match app.radio_state {
        RadioState::Disconnected => ("○", Style::default().fg(Color::DarkGray)),
        RadioState::Idle => ("○", Style::default().fg(Color::Yellow)),
        RadioState::Receiving => ("●", Style::default().fg(Color::Green)),
        RadioState::Transmitting => ("●", Style::default().fg(Color::Red)),
    };

    let title = format!("KAT v{}", VERSION);

    // Build radio info string with all settings
    let amp_str = if app.amp_enabled { "ON" } else { "OFF" };
    let radio_info = format!(
        "{} {} | {:.2} MHz | LNA:{} VGA:{} AMP:{}",
        status_symbol,
        app.radio_state,
        app.frequency_mhz(),
        app.lna_gain,
        app.vga_gain,
        amp_str
    );

    // Calculate padding for right-alignment
    let padding = area
        .width
        .saturating_sub(title.len() as u16 + radio_info.len() as u16 + 4);

    let header_line = Line::from(vec![
        Span::styled(title, Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" ".repeat(padding as usize)),
        Span::styled(radio_info, status_style),
    ]);

    let header = Paragraph::new(header_line).block(
        Block::default()
            .borders(Borders::ALL)
            .border_style(Style::default()),
    );

    frame.render_widget(header, area);
}

/// Render the context-sensitive help bar
fn render_help_bar(frame: &mut Frame, area: Rect, app: &App) {
    let help_text = match app.input_mode {
        InputMode::Normal => {
            "Enter: Actions | Tab: Settings | r: RX Toggle | :: Command | q: Quit"
        }
        InputMode::Command => "Enter: Execute | Esc: Cancel",
        InputMode::SignalMenu => "Up/Down: Navigate | Enter: Select | Esc: Close",
        InputMode::SettingsSelect => "Left/Right: Select | Tab: Cycle | Enter: Edit | Esc: Back",
        InputMode::SettingsEdit => "Up/Down: Change Value | Enter: Apply | Esc: Cancel",
        InputMode::StartupImport => "y: Import | n: Skip",
        InputMode::ExportFilename => {
            match app.export_format {
                Some(crate::app::ExportFormat::Fob) => "Enter: Next Field | Esc: Cancel Export",
                Some(crate::app::ExportFormat::Flipper) => "Enter: Save & Export | Esc: Cancel Export",
                None => "Enter: Confirm | Esc: Cancel",
            }
        }
        InputMode::FobMetaYear
        | InputMode::FobMetaMake
        | InputMode::FobMetaModel
        | InputMode::FobMetaRegion => "Enter: Next Field | Esc: Cancel Export",
        InputMode::FobMetaNotes => "Enter: Save & Export | Esc: Cancel Export",
    };

    let help = Paragraph::new(Line::from(Span::styled(
        format!(" {}", help_text),
        Style::default().fg(Color::DarkGray),
    )));

    frame.render_widget(help, area);
}

/// Center a rect of given width/height in the given area
fn centered_rect(width: u16, height: u16, area: Rect) -> Rect {
    let x = area.x + area.width.saturating_sub(width) / 2;
    let y = area.y + area.height.saturating_sub(height) / 2;
    Rect::new(x, y, width.min(area.width), height.min(area.height))
}

/// Render the startup import prompt overlay
fn render_startup_import_prompt(frame: &mut Frame, app: &App) {
    let count = app.pending_fob_files.len();
    let area = frame.area();
    let popup = centered_rect(50, 7, area);

    frame.render_widget(Clear, popup);

    let text = vec![
        Line::from(""),
        Line::from(Span::styled(
            format!("Found {} .fob file(s) in export directory.", count),
            Style::default().fg(Color::Yellow),
        )),
        Line::from(""),
        Line::from(Span::styled(
            "Import them? (y/n)",
            Style::default()
                .fg(Color::White)
                .add_modifier(Modifier::BOLD),
        )),
    ];

    let block = Block::default()
        .title(" Import Saved Signals ")
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Cyan));

    let paragraph = Paragraph::new(text)
        .block(block)
        .alignment(Alignment::Center)
        .wrap(Wrap { trim: true });

    frame.render_widget(paragraph, popup);
}

/// Render the export form overlay (filename + optional .fob metadata)
fn render_export_form(frame: &mut Frame, app: &App) {
    use crate::app::ExportFormat;

    let is_fob = app.export_format == Some(ExportFormat::Fob);
    let ext = if is_fob { ".fob" } else { ".sub" };

    let area = frame.area();
    // Taller popup for .fob (filename + 5 metadata fields), shorter for .sub (filename only)
    let popup_height = if is_fob { 21 } else { 11 };
    let popup = centered_rect(62, popup_height, area);

    frame.render_widget(Clear, popup);

    let active_style = Style::default()
        .fg(Color::Cyan)
        .add_modifier(Modifier::BOLD);
    let inactive_style = Style::default().fg(Color::DarkGray);
    let done_style = Style::default().fg(Color::Green);
    let value_style = Style::default().fg(Color::White);
    let dim_style = Style::default().fg(Color::DarkGray);
    let accent_style = Style::default().fg(Color::Yellow);
    let cursor = Span::styled(
        "_",
        Style::default()
            .fg(Color::Cyan)
            .add_modifier(Modifier::RAPID_BLINK),
    );

    // Build the ordered list of field modes for this export type
    // Filename is always first; .fob adds metadata fields after
    let field_modes: Vec<InputMode> = if is_fob {
        vec![
            InputMode::ExportFilename,
            InputMode::FobMetaYear,
            InputMode::FobMetaMake,
            InputMode::FobMetaModel,
            InputMode::FobMetaRegion,
            InputMode::FobMetaNotes,
        ]
    } else {
        vec![InputMode::ExportFilename]
    };

    let current_idx = field_modes
        .iter()
        .position(|m| *m == app.input_mode)
        .unwrap_or(0);

    let style_for = |idx: usize| -> Style {
        if idx == current_idx {
            active_style
        } else if idx < current_idx {
            done_style
        } else {
            inactive_style
        }
    };

    let mut lines = Vec::new();

    // --- Signal summary section ---
    if let Some(capture) = app
        .export_capture_id
        .and_then(|id| app.captures.iter().find(|c| c.id == id))
    {
        lines.push(Line::from(vec![
            Span::styled("  Signal:  ", dim_style),
            Span::styled(
                format!(
                    "#{:02} {} | {} | {} | 0x{}",
                    capture.id,
                    capture.protocol_name(),
                    capture.frequency_mhz(),
                    capture.modulation(),
                    capture.serial_hex(),
                ),
                accent_style,
            ),
        ]));
        lines.push(Line::from(vec![
            Span::styled("  Key:     ", dim_style),
            Span::styled(
                format!("0x{} ({})", capture.data_hex(), capture.encryption_type()),
                accent_style,
            ),
        ]));
    }

    lines.push(Line::from(Span::styled(
        "  ──────────────────────────────────────────────────────",
        dim_style,
    )));

    // --- Form fields ---
    struct FormField<'a> {
        label: &'a str,
        value: &'a str,
        placeholder: &'a str,
        idx: usize,
    }

    // Filename field (always present)
    let filename_display = format!("{}{}", app.export_filename, ext);
    let mut fields: Vec<FormField> = vec![
        FormField {
            label: "  File:    ",
            value: &filename_display,
            placeholder: "(enter filename)",
            idx: 0,
        },
    ];

    // .fob metadata fields
    if is_fob {
        fields.extend([
            FormField {
                label: "  Year:    ",
                value: &app.fob_meta_year,
                placeholder: "(e.g. 2024)",
                idx: 1,
            },
            FormField {
                label: "  Make:    ",
                value: &app.fob_meta_make,
                placeholder: "(auto-detected from protocol)",
                idx: 2,
            },
            FormField {
                label: "  Model:   ",
                value: &app.fob_meta_model,
                placeholder: "(e.g. Sportage, F-150)",
                idx: 3,
            },
            FormField {
                label: "  Region:  ",
                value: &app.fob_meta_region,
                placeholder: "(e.g. NA, EU, APAC, MEA)",
                idx: 4,
            },
            FormField {
                label: "  Notes:   ",
                value: &app.fob_meta_notes,
                placeholder: "(optional — color, trim, VIN, etc.)",
                idx: 5,
            },
        ]);
    }

    for field in &fields {
        let label_s = style_for(field.idx);
        let display_val = if field.value.is_empty() {
            field.placeholder
        } else {
            field.value
        };

        let val_s = if field.value.is_empty() && field.idx != current_idx {
            dim_style
        } else {
            value_style
        };

        let mut spans = vec![
            Span::styled(field.label, label_s),
            Span::styled(display_val.to_string(), val_s),
        ];

        // Show cursor on active field
        if field.idx == current_idx {
            spans.push(cursor.clone());
        }

        // Show checkmark for completed fields with values
        if field.idx < current_idx && !field.value.is_empty() {
            spans.push(Span::styled(" ✓", done_style));
        }

        lines.push(Line::from(spans));
    }

    lines.push(Line::from(""));

    // Progress indicator
    let total_fields = fields.len();
    let progress = format!(
        "  Step {}/{}",
        current_idx + 1,
        total_fields,
    );
    let hint = if current_idx == total_fields - 1 {
        "  Enter: Save & Export | Esc: Cancel"
    } else {
        "  Enter: Next | Esc: Cancel"
    };
    lines.push(Line::from(vec![
        Span::styled(progress, accent_style),
        Span::styled("  ", dim_style),
        Span::styled(hint, dim_style),
    ]));

    let title = if is_fob {
        " Export .fob — Filename & Vehicle Details "
    } else {
        " Export .sub (Flipper Zero) "
    };

    let block = Block::default()
        .title(title)
        .borders(Borders::ALL)
        .border_style(Style::default().fg(Color::Green));

    let paragraph = Paragraph::new(lines).block(block);

    frame.render_widget(paragraph, popup);
}