//! Generate Markdown from null-separated path lists.
//!
//! This module reads a stream of NUL-separated file paths, normalizes each path, skips duplicates,
//! and renders selected files into Markdown.

use std::{
    collections::HashSet,
    ffi::OsStr,
    io::{Read, Write},
    os::unix::ffi::OsStrExt,
    path::Path,
};

use crate::{
    logger::Logger,
    normalizer::Normalizer,
    renderer::{RenderOptions, Renderer},
    util::path_display::display_path,
};

const DEFAULT_PROJECT_NAME: &str = "Project Outline";

/// Generates Markdown for the files listed in `input`.
///
/// `input` is expected to contain a NUL-separated sequence of paths, such as output from
/// `find -print0` or `git ls-files -z`.
///
/// Relative input paths are resolved against `origin_base`. File headings use paths made relative
/// to `root`.
///
/// Duplicate files are skipped after normalization, while preserving the first occurrence order.
///
/// Rendering behavior such as file-size limits and placeholder output is controlled by
/// `render_options`.
pub fn generate_markdown_from_paths<R: Read, W: Write>(
    mut input: R,
    output: W,
    render_options: RenderOptions,
    root: &Path,
    origin_base: &Path,
    project_title: Option<&str>,
    logger: Logger,
) -> Result<(), Box<dyn std::error::Error>> {
    let mut buf = Vec::new();
    input.read_to_end(&mut buf)?;

    let normalizer = Normalizer::new(root, origin_base)?;

    let mut renderer = Renderer::new(output, render_options).with_logger(logger);
    let project_title = project_title.unwrap_or_else(|| derive_project_title(root));
    renderer.render_header(project_title)?;

    let mut seen_paths = HashSet::new();
    for segment in buf.split(|b| *b == 0) {
        if segment.is_empty() {
            continue;
        }

        let path = Path::new(OsStr::from_bytes(segment));
        let normalized_path = normalizer.normalize(path)?;
        if !seen_paths.insert(normalized_path.clone()) {
            logger.warn(format!(
                "skipping duplicate file: {}",
                display_path(&normalized_path.root_relative)
            ));
            continue;
        }
        renderer.render_path(&normalized_path)?;
    }
    Ok(())
}

fn derive_project_title(root: &Path) -> &str {
    if let Some(os_str_name) = root.file_name()
        && let Some(name) = os_str_name.to_str()
    {
        name
    } else {
        DEFAULT_PROJECT_NAME
    }
}

#[cfg(test)]
mod tests {
    use std::ffi::OsStr;
    use std::fs;
    use std::io::{Cursor, Read, Write};
    use std::os::unix::ffi::OsStrExt;
    use std::path::Path;

    use crate::logger::Logger;
    use crate::renderer::RenderOptions;
    use tempfile::tempdir;

    use super::{DEFAULT_PROJECT_NAME, derive_project_title, generate_markdown_from_paths};

    fn paths_to_null_sep_bytes(file_paths: &[&Path]) -> Vec<u8> {
        let mut output = Vec::new();
        for path in file_paths {
            output.extend(path.as_os_str().as_encoded_bytes());
            output.push(0);
        }
        output
    }

    fn generate_with_defaults<R: Read, W: Write>(
        input: R,
        output: W,
        root: &Path,
        origin_base: &Path,
        project_title: Option<&str>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let logger = Logger::default();
        let render_options = RenderOptions::default();
        generate_markdown_from_paths(
            input,
            output,
            render_options,
            root,
            origin_base,
            project_title,
            logger,
        )
    }

    #[test]
    fn cli_with_empty_input_produces_empty_project_with_specified_project_title() {
        let temp_dir = tempdir().unwrap();
        let input = Cursor::new(b"");
        let mut output = Vec::new();
        let root = temp_dir.path();
        let origin_base = temp_dir.path();

        generate_with_defaults(input, &mut output, root, origin_base, Some("Project name"))
            .unwrap();

        assert_eq!(String::from_utf8(output).unwrap(), "# Project name\n");
    }

    #[test]
    fn cli_reads_single_file_from_stdin() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path();
        let input = Cursor::new(b"test_main.rs\0");
        let mut output = Vec::new();
        let root = temp_dir.path();

        fs::write(origin_base.join("test_main.rs"), "fn main() {}").unwrap();

        generate_with_defaults(input, &mut output, root, origin_base, None).unwrap();

        let output_str = String::from_utf8(output).unwrap();

        assert!(output_str.contains("## File: test_main.rs"));
        assert!(output_str.contains("fn main() {}"));
    }

    #[test]
    fn cli_reads_multiple_files_in_order() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path();
        let input = Cursor::new(b"a.rs\0b.rs\0");
        let mut output = Vec::new();
        let root = temp_dir.path();

        fs::write(origin_base.join("a.rs"), "A").unwrap();
        fs::write(origin_base.join("b.rs"), "B").unwrap();

        generate_with_defaults(input, &mut output, root, origin_base, None).unwrap();

        let output = String::from_utf8(output).unwrap();

        let a_pos = output.find("a.rs").unwrap();
        let b_pos = output.find("b.rs").unwrap();

        assert!(a_pos < b_pos);
    }

    #[test]
    fn cli_normalizes_paths_before_rendering() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path();
        let input = Cursor::new(b"test/./main.rs\0");
        let mut output = Vec::new();
        let root = temp_dir.path();

        let write_dir = temp_dir.path().join("test");
        fs::create_dir_all(&write_dir).unwrap();
        fs::write(write_dir.join("main.rs"), "fn main() {}").unwrap();

        generate_with_defaults(input, &mut output, root, origin_base, None).unwrap();

        let output = String::from_utf8(output).unwrap();

        assert!(output.contains("## File: test/main.rs"));
    }

    #[test]
    fn cli_reads_from_origin_but_outputs_relative_to_root() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path().join("sandbox/src");
        let input = Cursor::new(b"main.rs\0");
        let mut output = Vec::new();
        let root = temp_dir.path().join("project");

        fs::create_dir_all(&origin_base).unwrap();
        fs::write(origin_base.join("main.rs"), "fn main() {}").unwrap();

        generate_with_defaults(input, &mut output, &root, &origin_base, None).unwrap();

        let output = String::from_utf8(output).unwrap();

        // Must contain file content → proves correct reading
        assert!(output.contains("fn main() {}"));

        // Must contain normalized path → proves normalization applied
        assert!(output.contains("sandbox/src/main.rs"));
    }

    #[test]
    fn cli_ignores_origin_when_input_path_is_absolute() {
        let temp_dir1 = tempdir().unwrap();
        let temp_dir2 = tempdir().unwrap();
        let origin_base = temp_dir2.path();
        let filepath = temp_dir1.path().join("test_main.rs");
        let input = Cursor::new(paths_to_null_sep_bytes(&[&filepath]));
        let mut output = Vec::new();
        let root = temp_dir2.path();
        fs::write(&filepath, "fn main() {}").unwrap();

        generate_with_defaults(input, &mut output, root, origin_base, None).unwrap();

        let output = String::from_utf8(output).unwrap();

        // Must contain file content → proves correct reading
        assert!(output.contains("fn main() {}"));
    }

    #[test]
    fn duplicate_files_in_sequence_are_skipped() {
        let temp_dir = tempdir().unwrap();
        let origin = temp_dir.path();
        let root = temp_dir.path();

        fs::write(origin.join("a.rs"), "A").unwrap();

        let input = Cursor::new(b"a.rs\0a.rs\0");
        let mut output = Vec::new();

        generate_with_defaults(input, &mut output, root, origin, None).unwrap();

        let output = String::from_utf8(output).unwrap();

        assert_eq!(output.matches("## File: a.rs").count(), 1);
    }

    #[test]
    fn duplicate_files_are_skipped_with_preserved_display_order_even_if_not_adjacent() {
        let temp_dir = tempdir().unwrap();
        let origin = temp_dir.path();
        let root = temp_dir.path();

        fs::write(origin.join("a.rs"), "A").unwrap();
        fs::write(origin.join("b.rs"), "B").unwrap();

        let input = Cursor::new(b"a.rs\0b.rs\0a.rs\0");
        let mut output = Vec::new();

        generate_with_defaults(input, &mut output, root, origin, None).unwrap();

        let output = String::from_utf8(output).unwrap();
        assert_eq!(output.matches("## File: a.rs").count(), 1);
        assert_eq!(output.matches("## File: b.rs").count(), 1);
        let a_pos = output.find("a.rs").unwrap();
        let b_pos = output.find("b.rs").unwrap();
        assert!(a_pos < b_pos);
    }

    #[test]
    fn lexically_equivalent_paths_are_detected_as_duplicates() {
        let temp_dir = tempdir().unwrap();
        let origin = temp_dir.path();
        let root = temp_dir.path();

        fs::create_dir_all(origin.join("bla")).unwrap();
        fs::write(origin.join("a.rs"), "A").unwrap();
        fs::write(origin.join("b.rs"), "B").unwrap();

        let input = Cursor::new(b"a.rs\0b.rs\0bla/../a.rs\0");
        let mut output = Vec::new();

        generate_with_defaults(input, &mut output, root, origin, None).unwrap();

        let output = String::from_utf8(output).unwrap();
        assert_eq!(output.matches("## File: a.rs").count(), 1);
    }

    #[test]
    fn project_title_is_derived_from_root_by_default_even_if_directory_does_not_exist() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path();
        let input = Cursor::new(b"");
        let mut output = Vec::new();
        let root = temp_dir.path().join("repo2markdown");

        generate_with_defaults(input, &mut output, &root, origin_base, None).unwrap();

        let output_str = String::from_utf8(output).unwrap();

        assert_eq!(output_str, "# repo2markdown\n");
    }

    #[test]
    fn project_title_fallsback_to_default_if_root_is_filesystem_root() {
        assert_eq!(derive_project_title(Path::new("/")), DEFAULT_PROJECT_NAME);
    }

    #[test]
    fn project_title_fallsback_if_root_ending_is_not_utf8() {
        let root = Path::new(OsStr::from_bytes(b"/root/fd\xC3"));
        assert_eq!(derive_project_title(root), DEFAULT_PROJECT_NAME);
    }

    #[test]
    fn deriving_project_title_from_root_ignores_trailing_slash() {
        let root = Path::new("/root/repo2markdown/");
        assert_eq!(derive_project_title(root), "repo2markdown");
    }

    #[test]
    fn generator_uses_render_options_for_large_file_placeholders() {
        let temp_dir = tempdir().unwrap();
        let origin_base = temp_dir.path();
        let root = temp_dir.path();

        let file_path = origin_base.join("big.txt");
        fs::write(&file_path, "A".repeat(10)).unwrap();

        let input = Cursor::new(b"big.txt\0");
        let mut output = Vec::new();

        let config = RenderOptions {
            placeholder_for_binary_files: false,
            placeholder_for_large_files: true,
            max_file_size: 5,
        };

        generate_markdown_from_paths(
            input,
            &mut output,
            config,
            root,
            origin_base,
            None,
            Logger::default(),
        )
        .unwrap();

        let output = String::from_utf8(output).unwrap();
        assert!(output.contains("## File: big.txt"));
        assert!(output.contains("[FILE TOO LARGE]"));
    }
}