Lumar / src / main.rs

mod config;
mod flake;
mod run;

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

use sly::block::Block;
use sly::color::Color;
use sly::component::RunError;
use sly::flow::Flow;
use sly::input;
use sly::style::{Span, Style};
use sly::terminal;
use sly::view::View;
use sly::widgets::{
    checklist::{CheckState, Checklist, ChecklistItem},
    multi_selector::{MultiSelector, MultiSelectorItem},
    selector::{Selector, SelectorItem},
    spinner::Spinner,
};

fn main() {
    let config = config::load_or_default();
    let width = terminal::get_size()
        .map(|(c, _)| c as usize)
        .unwrap_or(80);

    // ── Discovery ─────────────────────────────────────────────────────────
    let configs = discover_with_spinner(&config.flake.path, width);

    if configs.is_empty() {
        eprintln!("No NixOS, Home Manager, or Colmena configurations found in the flake at '{}'.", config.flake.path);
        eprintln!("Check your flake.nix and ensure `nix eval` works.");
        std::process::exit(1);
    }

    // ── Selection ──────────────────────────────────────────────────────────
    println!("Lumar — Nix Configuration Manager");
    println!("  Space: toggle  Enter: confirm  Ctrl+A: all  Ctrl+D: none  Esc: cancel");
    println!();

    let default_parallel = config.flake.parallel;
    let configs_for_flow = configs.clone();

    let flow = build_flow(configs_for_flow, default_parallel);

    let selection = match input::with_raw_mode(|mode| flow.run(mode)) {
        Ok(Ok(sel)) => sel,
        Ok(Err(RunError::Cancelled)) => {
            println!("Cancelled.");
            return;
        }
        Ok(Err(RunError::InputError(e))) => {
            eprintln!("Input error: {e}");
            std::process::exit(1);
        }
        Err(e) => {
            eprintln!("Terminal error: {e}");
            std::process::exit(1);
        }
    };

    // ── Execution ──────────────────────────────────────────────────────────
    println!();
    execute_with_display(selection.entries, &config, selection.parallel, width);
}

// ── Flow ──────────────────────────────────────────────────────────────────

struct Selection {
    entries: Vec<flake::ConfigEntry>,
    parallel: bool,
}

fn build_flow(configs: Vec<flake::ConfigEntry>, default_parallel: bool) -> Flow<Selection> {
    let items: Vec<MultiSelectorItem<usize>> = configs
        .iter()
        .enumerate()
        .map(|(i, entry)| {
            MultiSelectorItem::label_line(
                vec![
                    Span::styled(
                        format!("{:>12}  ", entry.kind.label()),
                        Style::new().fg(kind_color(&entry.kind)),
                    ),
                    Span::plain(entry.name.clone()),
                ],
                i,
            )
        })
        .collect();

    let ms = MultiSelector::new(items).min_selections(1);

    Flow::step(
        sly::widgets::multi_selector::multi_selector(ms),
        move |indices: Vec<usize>| {
            let selected: Vec<flake::ConfigEntry> =
                indices.iter().map(|&i| configs[i].clone()).collect();

            if selected.len() <= 1 {
                return Flow::done(Selection { entries: selected, parallel: false });
            }

            // Ask for execution mode
            let mut mode_items = vec![
                SelectorItem::new("Sequential — apply one after another", false),
                SelectorItem::new("Parallel  — apply all at once", true),
            ];
            if default_parallel {
                mode_items.reverse();
            }

            Flow::step(
                sly::widgets::selector::selector(Selector::new(mode_items)),
                move |parallel: bool| Flow::done(Selection { entries: selected, parallel }),
            )
        },
    )
}

fn kind_color(kind: &flake::ConfigKind) -> Color {
    match kind {
        flake::ConfigKind::NixOS => Color::Blue,
        flake::ConfigKind::HomeManager => Color::Green,
        flake::ConfigKind::Colmena => Color::Magenta,
    }
}

// ── Discovery ──────────────────────────────────────────────────────────────

fn discover_with_spinner(flake_path: &str, width: usize) -> Vec<flake::ConfigEntry> {
    let spin = Spinner::dots().label("Discovering flake configurations…");
    let mut view = View::create(&spin.frame(0), width);

    let (tx, rx) = mpsc::sync_channel::<Vec<flake::ConfigEntry>>(1);
    let path = flake_path.to_string();
    thread::spawn(move || {
        tx.send(flake::discover(&path)).ok();
    });

    let mut tick = 0usize;
    loop {
        thread::sleep(Duration::from_millis(80));
        if let Ok(configs) = rx.try_recv() {
            view.erase();
            return configs;
        }
        tick += 1;
        view.update(&spin.frame(tick));
    }
}

// ── Execution ──────────────────────────────────────────────────────────────

fn execute_with_display(
    entries: Vec<flake::ConfigEntry>,
    config: &config::Config,
    parallel: bool,
    width: usize,
) {
    let total = entries.len();
    let mode_label = if parallel { "parallel" } else { "sequential" };
    println!("Applying {} configuration(s) [{}]…\n", total, mode_label);

    let mut checklist = Checklist::new(
        entries
            .iter()
            .map(|e| ChecklistItem::new(format!("[{}] {}", e.kind.label(), e.name)))
            .collect(),
    );

    let spin = Spinner::braille();
    let mut view = View::create(
        &render_exec_block(&spin, 0, &checklist, width),
        width,
    );

    let (tx, rx) = mpsc::sync_channel::<run::RunMsg>(64);
    run::start(entries, config.clone(), parallel, tx);

    let mut tick = 0usize;
    let mut done_count = 0usize;

    loop {
        thread::sleep(Duration::from_millis(80));

        while let Ok(msg) = rx.try_recv() {
            match msg {
                run::RunMsg::Started(i) => checklist.set_state(i, CheckState::InProgress),
                run::RunMsg::Done(i, ok) => {
                    checklist.set_state(i, if ok { CheckState::Done } else { CheckState::Failed });
                    done_count += 1;
                }
            }
        }

        if done_count >= total {
            break;
        }

        tick += 1;
        view.update(&render_exec_block(&spin, tick, &checklist, width));
    }

    // Final render without spinner
    view.update(&checklist.to_block());
    view.finish();

    println!();
    let failed = (0..total)
        .filter(|&i| checklist.get(i).map(|e| e.state == CheckState::Failed).unwrap_or(false))
        .count();

    if failed == 0 {
        println!(
            "{}",
            sly::ansi::styled("All configurations applied successfully.", &[sly::ansi::fg(&Color::Green)])
        );
    } else {
        eprintln!(
            "{}",
            sly::ansi::styled(
                &format!("{} configuration(s) failed.", failed),
                &[sly::ansi::fg(&Color::Red)],
            )
        );
        std::process::exit(1);
    }
}

fn render_exec_block(spin: &Spinner, tick: usize, checklist: &Checklist, _width: usize) -> Block {
    Block::vstack(
        vec![
            Block::hstack(vec![spin.frame(tick), Block::text_plain(" Applying…")], 0),
            Block::empty(1),
            checklist.to_block(),
        ],
        0,
    )
}