rec/export/

makefile.rs

use std::fmt::Write;

use crate::models::Session;

use super::parameterize::{FormatType, Parameter, apply_parameters, render_for_format};
use super::{escape_makefile, format_timestamp};

/// Export a session as a Makefile.
///
/// Generates a Makefile with:
/// - Header comments (session name, date, command count)
/// - Make variable declarations when parameters are provided (`VAR ?= value`)
/// - `.PHONY` targets for each step
/// - Tab-indented recipes with `cd && command` per target
/// - Dollar sign escaping (`$` → `$$`)
/// - Annotations for failed commands
///
/// When `params` is `Some`, commands have auto-detected values replaced with
/// `$(VAR)` references and variable declarations are added before targets.
///
/// Each target runs independently with its own `cd` because
/// Makefile recipe lines each execute in a separate shell.
///
/// Empty sessions produce a valid Makefile with a "No commands recorded" note.
#[must_use]
pub fn export_makefile(session: &Session, params: Option<&[Parameter]>) -> String {
    let mut out = String::new();

    // Header
    out.push_str("# Generated by rec\n");
    writeln!(out, "# Session: {}", session.header.name).unwrap();
    writeln!(
        out,
        "# Recorded: {}",
        format_timestamp(session.header.started_at)
    )
    .unwrap();
    writeln!(out, "# Commands: {}", session.commands.len()).unwrap();

    // Parameter declarations
    if let Some(params) = params {
        if !params.is_empty() {
            out.push('\n');
            for param in params {
                let val = param.value.as_deref().unwrap_or(&param.original);
                writeln!(out, "{} ?= {}", param.name, val).unwrap();
            }
        }
    }

    if session.commands.is_empty() {
        out.push('\n');
        out.push_str("# No commands recorded\n");
    } else {
        for (i, cmd) in session.commands.iter().enumerate() {
            let step = i + 1;

            // Apply parameterization
            let (cmd_text, cwd_str) = if let Some(p) = params {
                let parameterized_cmd = apply_parameters(&cmd.command, p);
                let rendered_cmd = render_for_format(&parameterized_cmd, FormatType::Make);
                let parameterized_cwd = apply_parameters(&cmd.cwd.display().to_string(), p);
                let rendered_cwd = render_for_format(&parameterized_cwd, FormatType::Make);
                (rendered_cmd, rendered_cwd)
            } else {
                (cmd.command.clone(), cmd.cwd.display().to_string())
            };

            let escaped_cmd = escape_makefile(&cmd_text);

            out.push('\n');
            writeln!(out, ".PHONY: step-{step}").unwrap();
            writeln!(out, "step-{step}:").unwrap();
            writeln!(out, "\t# [{step}] {cmd_text} (from {cwd_str})").unwrap();

            // Annotate failed commands
            if let Some(code) = cmd.exit_code {
                if code != 0 {
                    writeln!(out, "\t# NOTE: exited with code {code}").unwrap();
                }
            }

            writeln!(out, "\tcd {cwd_str} && {escaped_cmd}").unwrap();
        }
    }

    out.push('\n');
    out.push_str("# Generated by rec\n");

    out
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::{Command, Session, SessionFooter, SessionHeader, SessionStatus};
    use std::collections::HashMap;
    use std::path::PathBuf;
    use uuid::Uuid;

    fn make_session(commands: Vec<Command>) -> Session {
        Session {
            header: SessionHeader {
                version: 2,
                id: Uuid::new_v4(),
                name: "test-session".to_string(),
                shell: "bash".to_string(),
                os: "linux".to_string(),
                hostname: "host".to_string(),
                env: HashMap::new(),
                tags: vec![],
                recovered: None,
                started_at: 1700000000.0,
            },
            commands,
            footer: Some(SessionFooter {
                ended_at: 1700000060.0,
                command_count: 0,
                status: SessionStatus::Completed,
            }),
        }
    }

    fn make_cmd(index: u32, command: &str, cwd: &str, exit_code: Option<i32>) -> Command {
        Command {
            index,
            command: command.to_string(),
            cwd: PathBuf::from(cwd),
            started_at: 1700000000.0 + f64::from(index),
            ended_at: Some(1700000001.0 + f64::from(index)),
            exit_code,
            duration_ms: Some(1000),
        }
    }

    #[test]
    fn test_empty_session() {
        let session = make_session(vec![]);
        let result = export_makefile(&session, None);

        assert!(result.contains("# Generated by rec"));
        assert!(result.contains("# No commands recorded"));
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_single_command() {
        let session = make_session(vec![make_cmd(0, "echo hello", "/home/user", Some(0))]);
        let result = export_makefile(&session, None);

        assert!(result.contains(".PHONY: step-1"));
        assert!(result.contains("step-1:"));
        assert!(result.contains("\t# [1] echo hello (from /home/user)"));
        assert!(result.contains("\tcd /home/user && echo hello"));
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_dollar_escaping() {
        let session = make_session(vec![make_cmd(0, "echo $HOME", "/home", Some(0))]);
        let result = export_makefile(&session, None);

        // Command in recipe should have $$ but comment should have original
        assert!(result.contains("\tcd /home && echo $$HOME"));
        // Comment shows original command
        assert!(result.contains("# [1] echo $HOME"));
    }

    #[test]
    fn test_each_target_has_cd() {
        let session = make_session(vec![
            make_cmd(0, "echo a", "/home", Some(0)),
            make_cmd(1, "echo b", "/home", Some(0)),
        ]);
        let result = export_makefile(&session, None);

        // Both targets should have cd (unlike bash which deduplicates)
        let cd_count = result.matches("\tcd /home && ").count();
        assert_eq!(cd_count, 2, "Each Makefile target needs its own cd");
    }

    #[test]
    fn test_tab_indentation() {
        let session = make_session(vec![make_cmd(0, "ls", "/home", Some(0))]);
        let result = export_makefile(&session, None);

        // Verify tab characters are used (not spaces)
        for line in result.lines() {
            if line.starts_with('\t') {
                // This is a recipe line - good, it has a tab
                assert!(
                    line.starts_with('\t'),
                    "Recipe line should start with tab: {line}"
                );
            }
        }
        // At least one line should be tab-indented
        assert!(result.lines().any(|l| l.starts_with('\t')));
    }

    #[test]
    fn test_failed_command_annotation() {
        let session = make_session(vec![make_cmd(0, "false", "/home", Some(1))]);
        let result = export_makefile(&session, None);

        assert!(result.contains("\t# NOTE: exited with code 1"));
    }

    #[test]
    fn test_output_ends_with_newline() {
        let session = make_session(vec![make_cmd(0, "ls", "/home", Some(0))]);
        let result = export_makefile(&session, None);
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_phony_per_target() {
        let session = make_session(vec![
            make_cmd(0, "echo a", "/home", Some(0)),
            make_cmd(1, "echo b", "/tmp", Some(0)),
            make_cmd(2, "echo c", "/var", Some(0)),
        ]);
        let result = export_makefile(&session, None);

        assert!(result.contains(".PHONY: step-1"));
        assert!(result.contains(".PHONY: step-2"));
        assert!(result.contains(".PHONY: step-3"));
    }
}