#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# File: tests/python/test_migration.py

"""Tests for the migration module (Overleaf import/export)."""

import zipfile
from pathlib import Path

import pytest

# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------


@pytest.fixture
def simple_overleaf_zip(tmp_path):
    """Create a minimal Overleaf-style ZIP for testing."""
    project_dir = tmp_path / "overleaf_project"
    project_dir.mkdir()

    # main.tex with \documentclass and inline metadata
    (project_dir / "main.tex").write_text(
        r"""\documentclass{article}
\title{Test Paper Title}
\author{John Doe}
\begin{document}
\maketitle
\input{sections/introduction}
\input{sections/methods}
\input{sections/results}
\input{sections/discussion}
\bibliography{refs}
\end{document}
""",
        encoding="utf-8",
    )

    # Sections
    sections = project_dir / "sections"
    sections.mkdir()
    (sections / "introduction.tex").write_text(
        r"\section{Introduction}" "\nThis is the introduction.",
        encoding="utf-8",
    )
    (sections / "methods.tex").write_text(
        r"\section{Methods}" "\nThese are the methods.",
        encoding="utf-8",
    )
    (sections / "results.tex").write_text(
        r"\section{Results}" "\nThese are the results.",
        encoding="utf-8",
    )
    (sections / "discussion.tex").write_text(
        r"\section{Discussion}" "\nThis is the discussion.",
        encoding="utf-8",
    )

    # Bibliography
    (project_dir / "refs.bib").write_text(
        "@article{doe2025, author={Doe}, title={Test}, year={2025}}\n",
        encoding="utf-8",
    )

    # Image
    images = project_dir / "images"
    images.mkdir()
    (images / "fig1.png").write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 100)

    # Create ZIP
    zip_path = tmp_path / "test_project.zip"
    with zipfile.ZipFile(zip_path, "w") as zf:
        for f in project_dir.rglob("*"):
            if f.is_file():
                zf.write(f, f.relative_to(project_dir))

    return zip_path


@pytest.fixture
def inline_overleaf_zip(tmp_path):
    """Overleaf ZIP with all content inline in main.tex (no \\input)."""
    project_dir = tmp_path / "inline_project"
    project_dir.mkdir()

    (project_dir / "main.tex").write_text(
        r"""\documentclass{article}
\title{Inline Paper}
\author{Jane Doe}
\begin{document}
\maketitle
\begin{abstract}
This is the abstract.
\end{abstract}
\section{Introduction}
Intro text here.
\section{Methods}
Methods text here.
\section{Results}
Results text here.
\section{Discussion}
Discussion text here.
\end{document}
""",
        encoding="utf-8",
    )

    zip_path = tmp_path / "inline_project.zip"
    with zipfile.ZipFile(zip_path, "w") as zf:
        for f in project_dir.rglob("*"):
            if f.is_file():
                zf.write(f, f.relative_to(project_dir))

    return zip_path


# ---------------------------------------------------------------------------
# Parsing tests
# ---------------------------------------------------------------------------


class TestParsing:
    def test_detect_main_tex(self, tmp_path):
        from scitex_writer.migration._parsing import detect_main_tex

        (tmp_path / "main.tex").write_text(r"\documentclass{article}", encoding="utf-8")
        (tmp_path / "helper.tex").write_text(r"\section{Foo}", encoding="utf-8")

        result = detect_main_tex(tmp_path)
        assert result is not None
        assert result.name == "main.tex"

    def test_detect_main_tex_no_documentclass(self, tmp_path):
        from scitex_writer.migration._parsing import detect_main_tex

        (tmp_path / "notes.tex").write_text("Just some text", encoding="utf-8")

        result = detect_main_tex(tmp_path)
        assert result is None

    def test_detect_main_tex_prefers_main(self, tmp_path):
        from scitex_writer.migration._parsing import detect_main_tex

        (tmp_path / "main.tex").write_text(r"\documentclass{article}", encoding="utf-8")
        (tmp_path / "paper.tex").write_text(
            r"\documentclass{article}", encoding="utf-8"
        )

        result = detect_main_tex(tmp_path)
        assert result.name == "main.tex"

    def test_classify_section_by_filename(self):
        from scitex_writer.migration._parsing import classify_section

        assert classify_section(Path("intro.tex"), "") == "introduction"
        assert classify_section(Path("methods.tex"), "") == "methods"
        assert classify_section(Path("results.tex"), "") == "results"
        assert classify_section(Path("discussion.tex"), "") == "discussion"
        assert classify_section(Path("abstract.tex"), "") == "abstract"
        assert classify_section(Path("random.tex"), "") is None

    def test_classify_section_by_heading(self):
        from scitex_writer.migration._parsing import classify_section

        content = r"\section{Introduction and Background}"
        assert classify_section(Path("ch1.tex"), content) == "introduction"

        content = r"\section{Experimental Procedure}"
        assert classify_section(Path("ch2.tex"), content) == "methods"

    def test_extract_metadata(self):
        from scitex_writer.migration._parsing import extract_metadata

        content = r"""
\title{My Great Paper}
\author{Alice Bob}
\keywords{science, testing}
"""
        meta = extract_metadata(content)
        assert meta["title"] == "My Great Paper"
        assert meta["authors_block"] == "Alice Bob"
        assert meta["keywords"] == "science, testing"

    def test_extract_metadata_empty(self):
        from scitex_writer.migration._parsing import extract_metadata

        meta = extract_metadata("No metadata here")
        assert meta["title"] is None
        assert meta["authors_block"] is None
        assert meta["keywords"] is None

    def test_split_inline_sections(self):
        from scitex_writer.migration._parsing import split_inline_sections

        content = r"""
\section{Introduction}
Intro text.
\section{Methods}
Methods text.
\section{Conclusion}
Conclusion text.
"""
        sections = split_inline_sections(content)
        assert "introduction" in sections
        assert "methods" in sections
        assert "discussion" in sections  # conclusion maps to discussion

    def test_unique_dest(self, tmp_path):
        from scitex_writer.migration._parsing import unique_dest

        f = tmp_path / "test.txt"
        assert unique_dest(f) == f

        f.write_text("existing")
        result = unique_dest(f)
        assert result.name == "test_1.txt"


# ---------------------------------------------------------------------------
# Import tests
# ---------------------------------------------------------------------------


class TestImport:
    def test_import_dry_run(self, simple_overleaf_zip, tmp_path):
        from scitex_writer.migration import from_overleaf

        result = from_overleaf(
            str(simple_overleaf_zip),
            output_dir=str(tmp_path / "output"),
            dry_run=True,
        )

        assert result["success"] is True
        assert result["dry_run"] is True
        assert "mapping_report" in result
        report = result["mapping_report"]
        assert report["main_tex"] == "main.tex"
        assert "introduction" in report["sections"]
        assert len(report["bib_files"]) == 1
        assert len(report["images"]) >= 1

    def test_import_nonexistent_zip(self):
        from scitex_writer.migration import from_overleaf

        result = from_overleaf("/nonexistent/file.zip")
        assert result["success"] is False
        assert "not found" in result["error"].lower()

    def test_import_invalid_zip(self, tmp_path):
        from scitex_writer.migration import from_overleaf

        fake = tmp_path / "fake.zip"
        fake.write_text("not a zip")
        result = from_overleaf(str(fake))
        assert result["success"] is False
        assert "not a valid zip" in result["error"].lower()

    def test_import_output_exists_no_force(self, simple_overleaf_zip, tmp_path):
        from scitex_writer.migration import from_overleaf

        out = tmp_path / "existing"
        out.mkdir()
        result = from_overleaf(str(simple_overleaf_zip), output_dir=str(out))
        assert result["success"] is False
        assert "already exists" in result["error"].lower()

    def test_import_inline_dry_run(self, inline_overleaf_zip, tmp_path):
        from scitex_writer.migration import from_overleaf

        result = from_overleaf(
            str(inline_overleaf_zip),
            output_dir=str(tmp_path / "inline_out"),
            dry_run=True,
        )

        assert result["success"] is True
        report = result["mapping_report"]
        assert report["metadata"]["title"] == "Inline Paper"

    def test_import_success_creates_project(self, simple_overleaf_zip, tmp_path):
        from unittest.mock import patch

        from scitex_writer.migration import from_overleaf

        out = tmp_path / "imported_project"

        def fake_clone(project_dir, git_strategy="child", **kwargs):
            """Create minimal scitex-writer directory structure."""
            p = Path(project_dir)
            p.mkdir(parents=True, exist_ok=True)
            (p / "00_shared" / "bib_files").mkdir(parents=True)
            (p / "00_shared" / "latex_styles").mkdir(parents=True)
            (p / "01_manuscript" / "contents" / "figures" / "caption_and_media").mkdir(
                parents=True
            )
            (p / "01_manuscript" / "contents" / "tables" / "caption_and_media").mkdir(
                parents=True
            )
            for sec in ["abstract", "introduction", "methods", "results", "discussion"]:
                (p / "01_manuscript" / "contents" / f"{sec}.tex").write_text("")
            return True

        with patch(
            "scitex_writer._project._create.clone_writer_project",
            side_effect=fake_clone,
        ):
            result = from_overleaf(str(simple_overleaf_zip), output_dir=str(out))

        assert result["success"] is True
        assert result["dry_run"] is False
        assert out.exists()

        # Sections were written
        contents = out / "01_manuscript" / "contents"
        assert (contents / "introduction.tex").exists()
        intro_text = (contents / "introduction.tex").read_text()
        assert "introduction" in intro_text.lower()

        # Bib was copied
        bib_files = list((out / "00_shared" / "bib_files").glob("*.bib"))
        assert len(bib_files) >= 1

        # Image was copied
        images = list((contents / "figures" / "caption_and_media").glob("*"))
        assert len(images) >= 1

        # Metadata was written
        assert (out / "00_shared" / "title.tex").exists()
        title = (out / "00_shared" / "title.tex").read_text()
        assert "Test Paper Title" in title

    def test_import_force_overwrites(self, simple_overleaf_zip, tmp_path):
        from unittest.mock import patch

        from scitex_writer.migration import from_overleaf

        out = tmp_path / "force_project"
        out.mkdir()
        (out / "marker.txt").write_text("old")

        def fake_clone(project_dir, git_strategy="child", **kwargs):
            p = Path(project_dir)
            p.mkdir(parents=True, exist_ok=True)
            (p / "00_shared" / "bib_files").mkdir(parents=True)
            (p / "01_manuscript" / "contents" / "figures" / "caption_and_media").mkdir(
                parents=True
            )
            (p / "01_manuscript" / "contents" / "tables" / "caption_and_media").mkdir(
                parents=True
            )
            for sec in ["abstract", "introduction", "methods", "results", "discussion"]:
                (p / "01_manuscript" / "contents" / f"{sec}.tex").write_text("")
            return True

        with patch(
            "scitex_writer._project._create.clone_writer_project",
            side_effect=fake_clone,
        ):
            result = from_overleaf(
                str(simple_overleaf_zip), output_dir=str(out), force=True
            )

        assert result["success"] is True
        assert not (out / "marker.txt").exists()


# ---------------------------------------------------------------------------
# Export tests
# ---------------------------------------------------------------------------


@pytest.fixture
def mock_scitex_project(tmp_path):
    """Create a minimal scitex-writer project structure for export testing."""
    proj = tmp_path / "mock_project"
    proj.mkdir()

    shared = proj / "00_shared"
    shared.mkdir()
    (shared / "title.tex").write_text("My Test Title\n")
    (shared / "authors.tex").write_text("Test Author\n")

    bib_dir = shared / "bib_files"
    bib_dir.mkdir()
    (bib_dir / "refs.bib").write_text(
        "@article{test2025, author={A}, title={B}, year={2025}}\n"
    )

    contents = proj / "01_manuscript" / "contents"
    contents.mkdir(parents=True)
    (contents / "introduction.tex").write_text(
        r"\section{Introduction}" "\nIntro content.\n"
    )
    (contents / "methods.tex").write_text(r"\section{Methods}" "\nMethods content.\n")
    (contents / "results.tex").write_text(r"\section{Results}" "\nResults content.\n")
    (contents / "discussion.tex").write_text(
        r"\section{Discussion}" "\nDiscussion content.\n"
    )

    fig_dir = contents / "figures" / "caption_and_media"
    fig_dir.mkdir(parents=True)
    (fig_dir / "fig1.png").write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 50)

    return proj


class TestExport:
    def test_export_nonexistent_project(self):
        from scitex_writer.migration import to_overleaf

        result = to_overleaf("/nonexistent/project")
        assert result["success"] is False

    def test_export_not_a_project(self, tmp_path):
        from scitex_writer.migration import to_overleaf

        result = to_overleaf(str(tmp_path))
        assert result["success"] is False
        assert "does not look like" in result["error"].lower()

    def test_export_dry_run(self, mock_scitex_project):
        from scitex_writer.migration import to_overleaf

        result = to_overleaf(str(mock_scitex_project), dry_run=True)

        assert result["success"] is True
        assert result["dry_run"] is True
        assert result["file_count"] > 0
        assert "main.tex" in result["files_included"]
        assert "references.bib" in result["files_included"]

    def test_export_creates_zip(self, mock_scitex_project, tmp_path):
        from scitex_writer.migration import to_overleaf

        zip_out = tmp_path / "export.zip"
        result = to_overleaf(str(mock_scitex_project), output_path=str(zip_out))

        assert result["success"] is True
        assert result["dry_run"] is False
        assert zip_out.exists()

        # Verify ZIP contents
        with zipfile.ZipFile(zip_out) as zf:
            names = zf.namelist()
            assert "main.tex" in names
            assert "references.bib" in names
            assert any("sections/" in n for n in names)
            assert any("images/" in n for n in names)

            # main.tex has documentclass and title
            main_content = zf.read("main.tex").decode()
            assert r"\documentclass" in main_content
            assert r"\title{My Test Title}" in main_content


# ---------------------------------------------------------------------------
# Module API tests
# ---------------------------------------------------------------------------


class TestModuleAPI:
    def test_migration_in_all(self):
        import scitex_writer as sw

        assert "migration" in sw.__all__

    def test_from_overleaf_callable(self):
        from scitex_writer import migration

        assert callable(migration.from_overleaf)

    def test_to_overleaf_callable(self):
        from scitex_writer import migration

        assert callable(migration.to_overleaf)

    def test_cli_help(self):
        import subprocess

        result = subprocess.run(
            ["scitex-writer", "migration", "--help"],
            capture_output=True,
            text=True,
            timeout=10,
        )
        assert result.returncode == 0
        assert "import" in result.stdout
        assert "export" in result.stdout


# EOF