tix-tracker 0.5.0

use std::path::Path;

use crate::assignee::git_identity;
use crate::board_store::BoardStore;
use crate::config::{Config, PlanningConfig, PlanningCycle, Team, starter_board};
use crate::error::{Result, TixError};
use crate::planning::Planner;

/// `tix init`: write the default `tix.toml` at `cwd`, seed the planning
/// registry, write the default board file, then create the first `Backlog`
/// milestone file. Refuses to overwrite an existing `tix.toml` (per
/// `contracts/tix-toml.md` §init).
pub fn run(cwd: &Path) -> Result<()> {
    let path = cwd.join("tix.toml");
    if path.exists() {
        return Err(TixError::Config(format!(
            "{} already exists — refusing to overwrite (delete it first if you want to re-init)",
            path.display()
        )));
    }
    let mut config = Config::starter();
    seed_planning(&mut config);
    // The board is written to its file store first; once `docs/boards/` exists
    // it is authoritative, so `tix.toml` must not carry a second copy.
    seed_board(cwd)?;
    write_init_config(&config, &path)?;
    seed_milestone(cwd)?;
    println!("Created {}", path.display());
    Ok(())
}

/// Write `docs/boards/default.md` with the starter board and a short body
/// documenting the sparse `card_order`, idempotently: a pre-existing file is
/// never overwritten. The `Default` cycle is implicit and needs no
/// `docs/cycles/` directory.
fn seed_board(cwd: &Path) -> Result<()> {
    let store = BoardStore::new(cwd);
    if store.dir().join("default.md").exists() {
        return Ok(());
    }
    store.save(
        "default",
        &starter_board(),
        Some("Only cards whose ordering differs from the default are listed in `card_order`."),
    )
}

/// Write the initial `tix.toml`. Board and cycle records live in their
/// `docs/` stores, so the serialized file omits the `[kanban]` section and
/// carries only the settings that remain authoritative here.
fn write_init_config(config: &Config, path: &Path) -> Result<()> {
    let dir = match path.parent() {
        Some(p) if !p.as_os_str().is_empty() => p.to_path_buf(),
        _ => Path::new(".").to_path_buf(),
    };
    std::fs::create_dir_all(&dir)?;

    let mut disk = config.clone();
    disk.kanban = crate::config::KanbanSection::default();
    let mut contents = toml::to_string_pretty(&disk)
        .map_err(|e| TixError::Config(format!("cannot serialize tix.toml: {e}")))?;
    contents.push_str(
        "\n# Optional TUI overrides; all other actions keep their defaults.\n# See docs/key-bindings.md for the complete reference.\n# [keybindings.board]\n# new_issue = [\"ctrl+n\"]\n",
    );
    contents.push_str(
        "\n# Optional new-issue templates for the F4 New Issue mode; selecting one\n\
         # pre-fills the form. Every field is optional; the title stays required.\n\
         # See docs/for-users/new-issue.md.\n\
         # [templates.bug]\n\
         # labels = [\"bug\"]\n\
         # body = \"## Steps to reproduce\\n\\n## Expected\\n\"\n",
    );
    contents.push_str(
        "\n# Frontmatter keys this project uses on purpose. An undeclared key is\n\
         # preserved on write but `tix lint` warns about it (usually a typo);\n\
         # declaring it here once stops the warning. Top-level names only.\n\
         # [custom_attributes]\n\
         # keys = [\"build_id\", \"reviewed_by\"]\n",
    );

    let file_name = path
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("tix.toml");
    let tmp = dir.join(format!("{file_name}.tmp-{}", std::process::id()));

    let write_result = (|| -> std::io::Result<()> {
        let mut f = std::fs::File::create(&tmp)?;
        use std::io::Write;
        f.write_all(contents.as_bytes())?;
        f.sync_all()?;
        Ok(())
    })();
    if let Err(e) = write_result {
        let _ = std::fs::remove_file(&tmp);
        return Err(TixError::Io(e));
    }

    if let Err(e) = std::fs::rename(&tmp, path) {
        let _ = std::fs::remove_file(&tmp);
        return Err(TixError::Io(e));
    }
    Ok(())
}

/// Fill the default config's planning surface: the milestones dir, the
/// auto-cycle counter at `1`, the implicit `Default` cycle (no end date, so
/// it is always current), the picker presets, and — when a git identity can
/// be read — a `default` team containing that identity (FR-002).
///
/// A user who never configures cycles keeps everything in `Default`; the
/// `docs/cycles/` directory is created only when a second cycle is added.
fn seed_planning(config: &mut Config) {
    config.milestones_dir = Some("docs/milestones".into());
    config.planning = PlanningConfig {
        default_cycle: Some(crate::cycle_store::DEFAULT_CYCLE_NAME.into()),
        default_milestone: Some("Backlog".into()),
        default_team: None,
        ..PlanningConfig::default()
    };
    config.cycles.insert(
        crate::cycle_store::DEFAULT_CYCLE_NAME.into(),
        PlanningCycle::default(),
    );
    if let Some(identity) = git_identity() {
        config.teams.insert(
            "default".into(),
            Team {
                members: vec![identity.to_string()],
            },
        );
        config.planning.default_team = Some("default".into());
    }
}

/// Create the initial `Backlog` milestone file
/// (`contracts/milestone-file-format.md`), idempotently: a pre-existing
/// file is never overwritten (`create_milestone_file` refuses, and produces
/// an [`TixError::InvalidInput`], which we absorb).
fn seed_milestone(cwd: &Path) -> Result<()> {
    let planner = Planner::from_config(Config::default(), cwd.to_path_buf());
    match planner.create_milestone_file(
        "Backlog",
        None,
        Some("Default milestone for unscheduled work"),
    ) {
        Ok(_) => Ok(()),
        Err(TixError::InvalidInput(_)) => Ok(()),
        Err(e) => Err(e),
    }
}