use ratatui::layout::{Alignment, Constraint, Layout, Rect};
use ratatui::style::{Color, Modifier, Style};
use ratatui::widgets::Paragraph;
use ratatui::Frame;

use crate::app::App;
use crate::engine::SequencerSnapshot;
use crate::widgets::{Orientation, Scope, VuMeter};

pub fn render(frame: &mut Frame, app: &mut App, snapshot: &SequencerSnapshot, area: Rect) {
    let [left_area, _spacer, vu_area] = Layout::horizontal([
        Constraint::Fill(1),
        Constraint::Length(2),
        Constraint::Length(8),
    ])
    .areas(area);

    let [scope_area, sequencer_area] = Layout::vertical([
        Constraint::Length(14),
        Constraint::Fill(1),
    ])
    .areas(left_area);

    render_scope(frame, app, scope_area);
    render_sequencer(frame, app, snapshot, sequencer_area);
    render_vu_meter(frame, app, vu_area);
}

const STEPS_PER_PAGE: usize = 32;

fn render_sequencer(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area: Rect) {
    if area.width < 50 {
        let msg = Paragraph::new("Terminal too narrow")
            .alignment(Alignment::Center)
            .style(Style::new().fg(Color::Rgb(120, 125, 135)));
        frame.render_widget(msg, area);
        return;
    }

    let pattern = app.current_edit_pattern();
    let length = pattern.length;
    let page = app.editor_ctx.step / STEPS_PER_PAGE;
    let page_start = page * STEPS_PER_PAGE;
    let steps_on_page = (page_start + STEPS_PER_PAGE).min(length) - page_start;

    let num_rows = steps_on_page.div_ceil(8);
    let steps_per_row = steps_on_page.div_ceil(num_rows);

    let spacing = num_rows.saturating_sub(1) as u16;
    let row_height = area.height.saturating_sub(spacing) / num_rows as u16;

    let row_constraints: Vec<Constraint> = (0..num_rows * 2 - 1)
        .map(|i| {
            if i % 2 == 0 {
                Constraint::Length(row_height)
            } else {
                Constraint::Length(1)
            }
        })
        .collect();
    let rows = Layout::vertical(row_constraints).split(area);

    for row_idx in 0..num_rows {
        let row_area = rows[row_idx * 2];
        let start_step = row_idx * steps_per_row;
        let end_step = (start_step + steps_per_row).min(steps_on_page);
        let cols_in_row = end_step - start_step;

        let col_constraints: Vec<Constraint> = (0..cols_in_row * 2 - 1)
            .map(|i| {
                if i % 2 == 0 {
                    Constraint::Fill(1)
                } else if i == cols_in_row - 1 {
                    Constraint::Length(2)
                } else {
                    Constraint::Length(1)
                }
            })
            .collect();
        let cols = Layout::horizontal(col_constraints).split(row_area);

        for col_idx in 0..cols_in_row {
            let step_idx = page_start + start_step + col_idx;
            if step_idx < length {
                render_tile(frame, cols[col_idx * 2], app, snapshot, step_idx);
            }
        }
    }

}

fn render_tile(
    frame: &mut Frame,
    area: Rect,
    app: &App,
    snapshot: &SequencerSnapshot,
    step_idx: usize,
) {
    let pattern = app.current_edit_pattern();
    let step = pattern.step(step_idx);
    let is_active = step.map(|s| s.active).unwrap_or(false);
    let is_linked = step.map(|s| s.source.is_some()).unwrap_or(false);
    let is_selected = step_idx == app.editor_ctx.step;

    let is_playing = if app.playback.playing {
        snapshot.get_step(app.editor_ctx.bank, app.editor_ctx.pattern) == Some(step_idx)
    } else {
        false
    };

    let link_color = step.and_then(|s| s.source).map(|src| {
        const BRIGHT: [(u8, u8, u8); 5] = [
            (180, 140, 220),
            (220, 140, 170),
            (220, 180, 130),
            (130, 180, 220),
            (170, 220, 140),
        ];
        const DIM: [(u8, u8, u8); 5] = [
            (90, 70, 120),
            (120, 70, 85),
            (120, 90, 65),
            (65, 90, 120),
            (85, 120, 70),
        ];
        let i = src % 5;
        (BRIGHT[i], DIM[i])
    });

    let (bg, fg) = match (is_playing, is_active, is_selected, is_linked) {
        (true, true, _, _) => (Color::Rgb(195, 85, 65), Color::White),
        (true, false, _, _) => (Color::Rgb(180, 120, 45), Color::Black),
        (false, true, true, true) => {
            let (r, g, b) = link_color.unwrap().0;
            (Color::Rgb(r, g, b), Color::Black)
        }
        (false, true, true, false) => (Color::Rgb(0, 220, 180), Color::Black),
        (false, true, false, true) => {
            let (r, g, b) = link_color.unwrap().1;
            (Color::Rgb(r, g, b), Color::White)
        }
        (false, true, false, false) => (Color::Rgb(45, 106, 95), Color::White),
        (false, false, true, _) => (Color::Rgb(80, 180, 255), Color::Black),
        (false, false, false, _) => (Color::Rgb(45, 48, 55), Color::Rgb(120, 125, 135)),
    };

    let symbol = if is_playing {
        "▶".to_string()
    } else if let Some(source) = step.and_then(|s| s.source) {
        format!("→{:02}", source + 1)
    } else {
        format!("{:02}", step_idx + 1)
    };

    let tile = Paragraph::new(symbol)
        .alignment(Alignment::Center)
        .style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));

    frame.render_widget(tile, area);
}

fn render_scope(frame: &mut Frame, app: &App, area: Rect) {
    let scope = Scope::new(&app.metrics.scope)
        .orientation(Orientation::Horizontal)
        .color(Color::Green);
    frame.render_widget(scope, area);
}

fn render_vu_meter(frame: &mut Frame, app: &App, area: Rect) {
    let vu = VuMeter::new(app.metrics.peak_left, app.metrics.peak_right);
    frame.render_widget(vu, area);
}