rec/export/

markdown.rs

use std::fmt::Write;

use crate::models::Session;

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

/// Export a session as Markdown documentation.
///
/// Generates a Markdown document with:
/// - Session title
/// - Summary table (date, duration, command count, tags)
/// - Parameters table when parameters are provided
/// - Numbered steps with fenced code blocks
/// - Directory and exit code metadata per step
///
/// When `params` is `Some`, a parameters table is added after the summary
/// and commands show `{{VAR}}` placeholders (Markdown passthrough).
///
/// Empty sessions produce a valid document with a "No commands recorded" note.
#[must_use]
pub fn export_markdown(session: &Session, params: Option<&[Parameter]>) -> String {
    let mut out = String::new();

    // Title
    writeln!(out, "# Session: {}", session.header.name).unwrap();
    out.push('\n');

    // Summary table
    let duration_str = match &session.footer {
        Some(f) => format_duration(f.ended_at - session.header.started_at),
        None => "N/A".to_string(),
    };

    let tags_str = if session.header.tags.is_empty() {
        "none".to_string()
    } else {
        session.header.tags.join(", ")
    };

    out.push_str("| Property | Value |\n");
    out.push_str("|----------|-------|\n");
    writeln!(
        out,
        "| Date | {} |",
        format_timestamp(session.header.started_at)
    )
    .unwrap();
    writeln!(out, "| Duration | {duration_str} |").unwrap();
    writeln!(out, "| Commands | {} |", session.commands.len()).unwrap();
    writeln!(out, "| Tags | {tags_str} |").unwrap();

    // Parameters table
    if let Some(params) = params {
        if !params.is_empty() {
            out.push('\n');
            out.push_str("## Parameters\n");
            out.push('\n');
            out.push_str("| Parameter | Value |\n");
            out.push_str("|-----------|-------|\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 (Markdown uses passthrough — keeps {{VAR}})
            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::Markdown);
                let parameterized_cwd = apply_parameters(&cmd.cwd.display().to_string(), p);
                let rendered_cwd = render_for_format(&parameterized_cwd, FormatType::Markdown);
                (rendered_cmd, rendered_cwd)
            } else {
                (cmd.command.clone(), cmd.cwd.display().to_string())
            };

            // Truncate long command text for heading
            let heading_text = truncate_command(&cmd_text, 60);

            out.push('\n');
            out.push_str("---\n");
            out.push('\n');
            writeln!(out, "### Step {step}: {heading_text}").unwrap();
            out.push('\n');
            out.push_str("```bash\n");
            writeln!(out, "{cmd_text}").unwrap();
            out.push_str("```\n");
            out.push('\n');

            let exit_str = match cmd.exit_code {
                Some(code) => code.to_string(),
                None => "unknown".to_string(),
            };

            writeln!(out, "> **Directory:** `{cwd_str}`").unwrap();
            writeln!(out, "> **Exit code:** {exit_str}").unwrap();
        }
    }

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

    out
}

/// Truncate a command string for use in step headings.
///
/// If the command is longer than `max_len`, truncates and appends "...".
fn truncate_command(command: &str, max_len: usize) -> String {
    if command.len() <= max_len {
        command.to_string()
    } else {
        format!("{}...", &command[..max_len])
    }
}

#[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>, tags: Vec<String>) -> 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,
                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![], vec![]);
        let result = export_markdown(&session, None);

        assert!(result.contains("# Session: test-session"));
        assert!(result.contains("*No commands recorded.*"));
        assert!(result.contains("*Generated by rec*"));
        assert!(result.ends_with('\n'));
    }

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

        assert!(result.contains("# Session: test-session"));
        assert!(result.contains("### Step 1: echo hello"));
        assert!(result.contains("```bash\necho hello\n```"));
        assert!(result.contains("> **Directory:** `/home/user`"));
        assert!(result.contains("> **Exit code:** 0"));
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_tags_display() {
        let session = make_session(vec![], vec!["deploy".to_string(), "prod".to_string()]);
        let result = export_markdown(&session, None);

        assert!(result.contains("| Tags | deploy, prod |"));
    }

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

        assert!(result.contains("| Tags | none |"));
    }

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

        // Duration should be calculated from started_at to ended_at (60 seconds)
        assert!(result.contains("| Duration | 1m 0s |"));
    }

    #[test]
    fn test_duration_no_footer() {
        let mut session = make_session(vec![], vec![]);
        session.footer = None;
        let result = export_markdown(&session, None);

        assert!(result.contains("| Duration | N/A |"));
    }

    #[test]
    fn test_unknown_exit_code() {
        let session = make_session(vec![make_cmd(0, "running-cmd", "/home", None)], vec![]);
        let result = export_markdown(&session, None);

        assert!(result.contains("> **Exit code:** unknown"));
    }

    #[test]
    fn test_truncate_long_command() {
        let long_cmd = "a".repeat(100);
        let session = make_session(vec![make_cmd(0, &long_cmd, "/home", Some(0))], vec![]);
        let result = export_markdown(&session, None);

        // Step heading should be truncated
        let expected_heading = format!("### Step 1: {}...", "a".repeat(60));
        assert!(result.contains(&expected_heading));

        // But code block should have full command
        assert!(result.contains(&format!("```bash\n{long_cmd}\n```")));
    }

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

        // Should have --- separators
        assert!(result.contains("---\n\n### Step 1:"));
        assert!(result.contains("---\n\n### Step 2:"));
    }

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

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

        assert!(result.contains("```bash"));
        assert!(result.contains("```\n"));
    }

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

        assert!(result.contains("| Property | Value |"));
        assert!(result.contains("|----------|-------|"));
        assert!(result.contains("| Date |"));
        assert!(result.contains("| Duration |"));
        assert!(result.contains("| Commands | 0 |"));
        assert!(result.contains("| Tags |"));
    }
}