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, Spectrum, VuMeter};

pub fn render(frame: &mut Frame, app: &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 show_scope = app.audio.config.show_scope;
    let show_spectrum = app.audio.config.show_spectrum;
    let viz_height = if show_scope || show_spectrum { 14 } else { 0 };

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

    if show_scope && show_spectrum {
        let [scope_area, _, spectrum_area] = Layout::horizontal([
            Constraint::Percentage(50),
            Constraint::Length(2),
            Constraint::Percentage(50),
        ])
        .areas(viz_area);
        render_scope(frame, app, scope_area);
        render_spectrum(frame, app, spectrum_area);
    } else if show_scope {
        render_scope(frame, app, viz_area);
    } else if show_spectrum {
        render_spectrum(frame, app, viz_area);
    }

    render_sequencer(frame, app, snapshot, sequencer_area);

    // Calculate actual grid height to align VU meter
    let pattern = app.current_edit_pattern();
    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(pattern.length) - page_start;
    let num_rows = steps_on_page.div_ceil(8);
    let spacing = num_rows.saturating_sub(1) as u16;
    let row_height = sequencer_area.height.saturating_sub(spacing) / num_rows as u16;
    let actual_grid_height = row_height * num_rows as u16 + spacing;

    let aligned_vu_area = Rect {
        y: sequencer_area.y,
        height: actual_grid_height,
        ..vu_area
    };

    render_vu_meter(frame, app, aligned_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 in_selection = app.editor_ctx.selection_range()
        .map(|r| r.contains(&step_idx))
        .unwrap_or(false);

    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, in_selection) {
        (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, _, _, true) => (Color::Rgb(0, 170, 140), 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, _, _, true) => (Color::Rgb(60, 140, 200), Color::Black),
        (false, false, false, _, _) => (Color::Rgb(45, 48, 55), Color::Rgb(120, 125, 135)),
    };

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

    // For linked steps, get the name from the source step
    let step_name = if let Some(src) = source_idx {
        pattern.step(src).and_then(|s| s.name.as_ref())
    } else {
        step.and_then(|s| s.name.as_ref())
    };
    let num_lines = if step_name.is_some() { 2u16 } else { 1u16 };
    let content_height = num_lines;
    let y_offset = area.height.saturating_sub(content_height) / 2;

    // Fill background for entire tile
    let bg_fill = Paragraph::new("").style(Style::new().bg(bg));
    frame.render_widget(bg_fill, area);

    if let Some(name) = step_name {
        let name_area = Rect {
            x: area.x,
            y: area.y + y_offset,
            width: area.width,
            height: 1,
        };
        let name_widget = Paragraph::new(name.as_str())
            .alignment(Alignment::Center)
            .style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
        frame.render_widget(name_widget, name_area);

        let symbol_area = Rect {
            x: area.x,
            y: area.y + y_offset + 1,
            width: area.width,
            height: 1,
        };
        let symbol_widget = Paragraph::new(symbol)
            .alignment(Alignment::Center)
            .style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
        frame.render_widget(symbol_widget, symbol_area);
    } else {
        let centered_area = Rect {
            x: area.x,
            y: area.y + y_offset,
            width: area.width,
            height: 1,
        };
        let tile = Paragraph::new(symbol)
            .alignment(Alignment::Center)
            .style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
        frame.render_widget(tile, centered_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_spectrum(frame: &mut Frame, app: &App, area: Rect) {
    let area = Rect { height: area.height.saturating_sub(1), ..area };
    let spectrum = Spectrum::new(&app.metrics.spectrum);
    frame.render_widget(spectrum, 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);
}