//! License key management screen — list, generate, revoke keys.

use makeover_tui::makeover_layout::{Column, Priority, Width};
use makeover_tui::table::{self, Cell, Sizing, TableStyle};
use ratatui::Frame;
use ratatui::layout::{Constraint, Layout, Rect};
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, Borders, Paragraph, TableState};

use super::App;

/// The license key columns. The key code is the row; whether it still works is
/// the next thing asked of it, and the activation count and the date after
/// that.
const KEY_COLUMNS: [Column<'static>; 4] = [
    Column {
        name: "Key",
        width: Width::Fill,
        priority: Priority::Essential,
        sortable: false,
        sorted: None,
    },
    Column {
        name: "Status",
        width: Width::Fixed,
        priority: Priority::Secondary,
        sortable: false,
        sorted: None,
    },
    Column {
        name: "Activations",
        width: Width::Fixed,
        priority: Priority::Optional,
        sortable: false,
        sorted: None,
    },
    Column {
        name: "Created",
        width: Width::Fixed,
        priority: Priority::Optional,
        sortable: false,
        sorted: None,
    },
];

/// The tracks the hand-written `Constraint`s carried.
const KEY_SIZING: Sizing<'static> = Sizing {
    lengths: &[
        ("Key", 24),
        ("Status", 10),
        ("Activations", 12),
        ("Created", 12),
    ],
    fallback: 12,
};

pub(crate) fn render(frame: &mut Frame, app: &App) {
    let area = frame.area();

    let item_title = app.keys_item_title.as_deref().unwrap_or("License Keys");

    let title = Line::from(vec![
        Span::styled(
            " Makenot.work ",
            Style::default().add_modifier(Modifier::BOLD),
        ),
        Span::raw(" -- "),
        Span::styled(item_title, Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" -- Keys "),
    ]);

    let block = Block::default()
        .title(title)
        .borders(Borders::ALL)
        .border_style(Style::default().fg(app.theme.line_border));

    let inner = block.inner(area);
    frame.render_widget(block, area);

    let chunks = Layout::vertical([
        Constraint::Length(1), // spacer
        Constraint::Length(1), // section header
        Constraint::Min(3),    // key list
        Constraint::Length(1), // status line
        Constraint::Length(1), // keybindings
    ])
    .split(inner);

    // Section header
    let count = app.license_keys.len();
    let header = Paragraph::new(Line::from(vec![
        Span::raw("  "),
        Span::styled("Keys", Style::default().add_modifier(Modifier::BOLD)),
        if count == 0 {
            Span::raw("")
        } else {
            Span::raw(format!(" ({count})"))
        },
    ]));
    frame.render_widget(header, chunks[1]);

    // Key list
    if app.loading {
        let loading = Paragraph::new("  Loading...");
        frame.render_widget(loading, chunks[2]);
    } else if app.license_keys.is_empty() {
        let empty = Paragraph::new("  No license keys. Press [g] to generate one.");
        frame.render_widget(empty, chunks[2]);
    } else {
        render_key_table(frame, app, chunks[2]);
    }

    // Status line
    if let Some(ref status) = app.keys_status {
        let style = if status.starts_with("Error") {
            Style::default().fg(app.theme.status_danger)
        } else {
            Style::default().fg(app.theme.status_success)
        };
        let status_line = Paragraph::new(Line::from(vec![
            Span::raw("  "),
            Span::styled(status.as_str(), style),
        ]));
        frame.render_widget(status_line, chunks[3]);
    }

    // Keybindings
    let mut key_spans = vec![
        Span::raw("  "),
        Span::styled("[j/k]", Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" Nav  "),
        Span::styled("[g]", Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" Generate  "),
    ];

    if !app.license_keys.is_empty() {
        key_spans.extend([
            Span::styled("[x]", Style::default().add_modifier(Modifier::BOLD)),
            Span::raw(" Revoke  "),
        ]);
    }

    key_spans.extend([
        Span::styled("[r]", Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" Refresh  "),
        Span::styled("[Esc]", Style::default().add_modifier(Modifier::BOLD)),
        Span::raw(" Back"),
    ]);

    let keys =
        Paragraph::new(Line::from(key_spans)).style(Style::default().fg(app.theme.content_muted));
    frame.render_widget(keys, chunks[4]);
}

fn render_key_table(frame: &mut Frame, app: &App, area: Rect) {
    let area = super::indent(area, 2);

    let rows: Vec<Vec<Cell>> = app
        .license_keys
        .iter()
        .map(|key| {
            let activations = match key.max_activations {
                Some(max) => format!("{}/{}", key.activation_count, max),
                None => key.activation_count.to_string(),
            };

            vec![
                Cell::new("Key", key.key_code.as_str()),
                Cell::new("Status", if key.is_revoked { "Revoked" } else { "Active" }),
                Cell::new("Activations", activations),
                Cell::new(
                    "Created",
                    key.created_at.get(..10).unwrap_or(&key.created_at),
                ),
            ]
        })
        .collect();

    let style = TableStyle::from_theme(&app.theme);
    let table = table::table(&KEY_COLUMNS, &rows, &KEY_SIZING, &style, area.width);
    let mut state = TableState::default().with_selected(Some(app.selected_index));
    frame.render_stateful_widget(table, area, &mut state);
}