"""Tests for the OCR option surface added to the hybrid server.

Covers:
    * `create_converter` delegation to docling's `get_ocr_factory`
    * Defaults preserve prior behavior (do_ocr=True, engine=easyocr)
    * `disable_ocr=True` -> do_ocr=False (#387)
    * Engine selection produces the matching OcrOptions subclass (#436, #439)
    * `psm` is applied only for Tesseract engines (silently ignored otherwise)
    * Unknown / denylisted engines exit with a clear message
    * argparse `--no-ocr` and `--force-ocr` are mutually exclusive
    * argparse `--ocr-engine` choices exclude `kserve_v2_ocr`
"""

import argparse
import io
from contextlib import redirect_stderr
from unittest.mock import patch

import pytest

from opendataloader_pdf import hybrid_server


# ---------- create_converter: factory delegation ----------

def _capture_pipeline_options(**kwargs):
    """Call create_converter while mocking the docling document_converter so we
    can introspect the PdfPipelineOptions instance that would be passed in.
    """
    captured = {}

    def fake_pdf_format_option(*, pipeline_options):
        captured["pipeline_options"] = pipeline_options
        return object()

    with patch(
        "docling.document_converter.DocumentConverter"
    ) as mock_dc, patch(
        "docling.document_converter.PdfFormatOption", side_effect=fake_pdf_format_option
    ):
        mock_dc.return_value = object()
        hybrid_server.create_converter(**kwargs)

    return captured["pipeline_options"]


def test_defaults_preserve_prior_behavior():
    """No flags -> do_ocr=True, EasyOcrOptions (matches pre-change behavior)."""
    from docling.datamodel.pipeline_options import EasyOcrOptions

    opts = _capture_pipeline_options()
    assert opts.do_ocr is True
    assert isinstance(opts.ocr_options, EasyOcrOptions)


def test_disable_ocr_sets_do_ocr_false():
    """`disable_ocr=True` -> do_ocr=False (#387)."""
    opts = _capture_pipeline_options(disable_ocr=True)
    assert opts.do_ocr is False


def test_ocr_engine_tesseract_yields_tesseract_options():
    """`ocr_engine='tesseract'` -> TesseractCliOcrOptions (#439 path)."""
    from docling.datamodel.pipeline_options import TesseractCliOcrOptions

    opts = _capture_pipeline_options(ocr_engine="tesseract")
    assert isinstance(opts.ocr_options, TesseractCliOcrOptions)


def test_ocr_engine_rapidocr_yields_rapidocr_options():
    """`ocr_engine='rapidocr'` -> RapidOcrOptions (#436 path)."""
    from docling.datamodel.pipeline_options import RapidOcrOptions

    opts = _capture_pipeline_options(ocr_engine="rapidocr")
    assert isinstance(opts.ocr_options, RapidOcrOptions)


def test_force_full_page_ocr_propagates_to_engine_options():
    """`force_full_page_ocr=True` flows to the engine's options instance."""
    opts = _capture_pipeline_options(
        ocr_engine="rapidocr", force_full_page_ocr=True
    )
    assert opts.ocr_options.force_full_page_ocr is True


def test_ocr_lang_overrides_engine_default():
    """A non-empty ocr_lang list replaces the engine's default lang."""
    opts = _capture_pipeline_options(
        ocr_engine="tesseract", ocr_lang=["mal", "eng"]
    )
    assert opts.ocr_options.lang == ["mal", "eng"]


def test_psm_is_applied_to_tesseract():
    """`psm` is applied when the engine is Tesseract."""
    opts = _capture_pipeline_options(ocr_engine="tesseract", psm=6)
    assert opts.ocr_options.psm == 6


def test_psm_is_ignored_for_non_tesseract_engines():
    """`psm` is silently ignored for engines that do not expose it."""
    # EasyOcrOptions has no `psm` field; passing psm should not raise.
    opts = _capture_pipeline_options(ocr_engine="easyocr", psm=6)
    assert not hasattr(opts.ocr_options, "psm")


def test_ocr_engine_auto_yields_auto_options():
    """`ocr_engine='auto'` -> OcrAutoOptions; engine choice is deferred to docling."""
    from docling.datamodel.pipeline_options import OcrAutoOptions

    opts = _capture_pipeline_options(ocr_engine="auto")
    assert isinstance(opts.ocr_options, OcrAutoOptions)


def test_unknown_engine_raises_value_error_with_clear_message():
    """An unknown engine kind raises ValueError listing valid engines.

    ValueError (not SystemExit) keeps the function library-friendly: programmatic
    callers can catch and retry with a different engine. main() relies on
    argparse `choices` to gate invalid CLI input separately.
    """
    with pytest.raises(ValueError) as excinfo:
        _capture_pipeline_options(ocr_engine="bogus-engine")
    msg = str(excinfo.value)
    assert "bogus-engine" in msg
    assert "Available engines" in msg


def test_create_converter_rejects_denylisted_engine():
    """Programmatic callers cannot bypass `_OCR_ENGINE_DENYLIST` via create_converter().

    The CLI layer rejects denylisted engines via argparse `choices`. This test
    locks in the same enforcement at the function-call layer, so importing the
    module and passing `ocr_engine="kserve_v2_ocr"` directly fails with a clear
    ValueError instead of building a converter that fails opaquely on the first
    request.
    """
    with pytest.raises(ValueError) as excinfo:
        _capture_pipeline_options(ocr_engine="kserve_v2_ocr")
    msg = str(excinfo.value)
    assert "kserve_v2_ocr" in msg
    assert "hybrid local mode" in msg
    assert "Available engines" in msg
    # Must also mention the denylist explicitly so a future maintainer searching
    # for the constant lands here.
    assert "_OCR_ENGINE_DENYLIST" in msg


# ---------- argparse: --no-ocr / --force-ocr / --ocr-engine / --psm ----------

def _build_parser_subset():
    """Reconstruct the OCR-relevant argparse subset from main().

    Mirrors the layout in hybrid_server.main() so changes to the CLI surface
    are caught by these tests. Uses the same `_OCR_ENGINE_DENYLIST` module
    constant as production code so tests stay in sync with main() automatically.
    """
    from docling.models.factories import get_ocr_factory

    parser = argparse.ArgumentParser()
    ocr_mode = parser.add_mutually_exclusive_group()
    ocr_mode.add_argument("--force-ocr", action="store_true")
    ocr_mode.add_argument("--no-ocr", action="store_true")

    choices = sorted(
        set(get_ocr_factory(allow_external_plugins=False).registered_kind)
        - hybrid_server._OCR_ENGINE_DENYLIST
    )
    parser.add_argument(
        "--ocr-engine", default="easyocr", choices=choices
    )
    parser.add_argument("--psm", type=int, default=None)
    parser.add_argument("--ocr-lang", default=None)
    return parser


def test_argparse_defaults():
    """No flags -> no_ocr=False, force_ocr=False, engine=easyocr, psm=None."""
    args = _build_parser_subset().parse_args([])
    assert args.no_ocr is False
    assert args.force_ocr is False
    assert args.ocr_engine == "easyocr"
    assert args.psm is None


def test_argparse_no_ocr_and_force_ocr_are_mutually_exclusive():
    """Passing both --no-ocr and --force-ocr exits with an argparse error."""
    err = io.StringIO()
    with pytest.raises(SystemExit), redirect_stderr(err):
        _build_parser_subset().parse_args(["--no-ocr", "--force-ocr"])
    assert "not allowed with argument" in err.getvalue()


def test_argparse_kserve_engine_is_rejected():
    """`--ocr-engine kserve_v2_ocr` is rejected (denylist filter)."""
    err = io.StringIO()
    with pytest.raises(SystemExit), redirect_stderr(err):
        _build_parser_subset().parse_args(["--ocr-engine", "kserve_v2_ocr"])
    assert "invalid choice" in err.getvalue()


def test_argparse_tesseract_path_for_issue_439():
    """The CLI invocation that resolves #439 parses cleanly."""
    args = _build_parser_subset().parse_args(
        ["--ocr-engine", "tesseract", "--ocr-lang", "mal", "--force-ocr"]
    )
    assert args.ocr_engine == "tesseract"
    assert args.ocr_lang == "mal"
    assert args.force_ocr is True
    assert args.no_ocr is False


def test_argparse_psm_accepted_as_integer():
    """`--psm 6` is parsed as an integer.

    Range and semantics belong to Tesseract / docling; this server passes the
    integer through unchanged. Out-of-range values surface from docling /
    Tesseract at conversion time, not here.
    """
    args = _build_parser_subset().parse_args(
        ["--ocr-engine", "tesseract", "--psm", "6"]
    )
    assert args.psm == 6


# ---------- _check_ocr_engine_available ----------

def test_engine_check_easyocr_always_ok():
    """easyocr ships with the `[hybrid]` extra; check is a no-op."""
    ok, msg = hybrid_server._check_ocr_engine_available("easyocr")
    assert ok is True
    assert msg == ""


def test_engine_check_auto_always_ok():
    """`auto` defers engine choice to docling; check is a no-op."""
    ok, msg = hybrid_server._check_ocr_engine_available("auto")
    assert ok is True
    assert msg == ""


def test_engine_check_unknown_kind_returns_false():
    """Unknown engine kinds fail closed instead of silently passing.

    Before this contract was tightened, the helper returned `(True, "")` for any
    engine name it did not recognize, so a docling release that registered a
    new engine kind would slip past the probe and fail at first conversion.
    Locks in the fail-closed behavior.
    """
    ok, msg = hybrid_server._check_ocr_engine_available("hypothetical_new_engine")
    assert ok is False
    assert "hypothetical_new_engine" in msg
    # Maintainer-targeted hint: where to add the probe branch.
    assert "_check_ocr_engine_available" in msg


def test_engine_check_tesseract_missing_binary():
    """`tesseract` engine without the binary on PATH fails with an actionable message."""
    with patch("shutil.which", return_value=None):
        ok, msg = hybrid_server._check_ocr_engine_available("tesseract")
    assert ok is False
    assert "tesseract" in msg.lower()
    assert "PATH" in msg


def test_engine_check_tesseract_present():
    """`tesseract` engine passes when the binary resolves on PATH."""
    with patch("shutil.which", return_value="/usr/bin/tesseract"):
        ok, msg = hybrid_server._check_ocr_engine_available("tesseract")
    assert ok is True
    assert msg == ""


def test_engine_check_tesserocr_missing_package():
    """`tesserocr` engine without the Python package fails with install hint."""
    with patch("importlib.util.find_spec", return_value=None):
        ok, msg = hybrid_server._check_ocr_engine_available("tesserocr")
    assert ok is False
    assert "tesserocr" in msg
    assert "pip install" in msg


def test_engine_check_rapidocr_missing_package():
    """`rapidocr` engine without the Python package fails with install hint."""
    with patch("importlib.util.find_spec", return_value=None):
        ok, msg = hybrid_server._check_ocr_engine_available("rapidocr")
    assert ok is False
    assert "rapidocr" in msg
    assert "onnxruntime" in msg


def test_engine_check_rapidocr_missing_onnxruntime():
    """`rapidocr` installed without `onnxruntime` fails with a backend-specific hint."""
    # Return a truthy spec for rapidocr, None for onnxruntime, None for anything else.
    def fake_find_spec(name):
        return object() if name == "rapidocr" else None

    with patch("importlib.util.find_spec", side_effect=fake_find_spec):
        ok, msg = hybrid_server._check_ocr_engine_available("rapidocr")
    assert ok is False
    assert "onnxruntime" in msg
    # The message should not duplicate the "rapidocr is not installed" wording.
    assert "rapidocr` Python package" not in msg


def test_engine_check_ocrmac_off_macos():
    """`ocrmac` selected on a non-Darwin platform fails with a clear platform message."""
    with patch("sys.platform", "linux"):
        ok, msg = hybrid_server._check_ocr_engine_available("ocrmac")
    assert ok is False
    assert "macOS" in msg


def test_engine_check_ocrmac_on_macos_missing_package():
    """`ocrmac` on macOS without the `ocrmac` Python package fails with install hint."""
    with patch("sys.platform", "darwin"), patch(
        "importlib.util.find_spec", return_value=None
    ):
        ok, msg = hybrid_server._check_ocr_engine_available("ocrmac")
    assert ok is False
    assert "ocrmac" in msg
    assert "pip install" in msg
    # Should NOT be the platform-mismatch message.
    assert "macOS only" not in msg and "not macOS" not in msg


# ---------- --no-ocr ignored-flag warning ----------

def _run_main_to_warning(argv, monkeypatch, caplog):
    """Drive `main()` far enough to capture the --no-ocr warning, then short-circuit.

    `main()` ends in `uvicorn.run(...)`; we patch `create_app` and `uvicorn.run`
    so the function returns cleanly after argparse + the warning logic without
    starting a server.
    """
    monkeypatch.setattr("sys.argv", ["opendataloader-pdf-hybrid", *argv])

    # Skip dep import checks — pytest already runs inside the [hybrid] env.
    monkeypatch.setattr(hybrid_server, "_check_dependencies", lambda: None)

    # Avoid building a real DocumentConverter / FastAPI app.
    monkeypatch.setattr(hybrid_server, "create_app", lambda **kwargs: object())

    # Stub uvicorn so main() returns instead of starting a server.
    fake_uvicorn = type("FakeUvicorn", (), {"run": staticmethod(lambda *a, **k: None)})
    monkeypatch.setitem(__import__("sys").modules, "uvicorn", fake_uvicorn)

    caplog.set_level("WARNING", logger=hybrid_server.logger.name)
    hybrid_server.main()


def test_no_ocr_warns_when_engine_explicitly_set(monkeypatch, caplog):
    """`--no-ocr --ocr-engine tesseract` warns that --ocr-engine has no effect."""
    _run_main_to_warning(
        ["--no-ocr", "--ocr-engine", "tesseract"], monkeypatch, caplog
    )
    warnings = [r.message for r in caplog.records if r.levelname == "WARNING"]
    assert any("--ocr-engine tesseract" in w for w in warnings), warnings


def test_no_ocr_warns_when_engine_explicitly_set_to_easyocr(monkeypatch, caplog):
    """Explicit `--ocr-engine easyocr` under --no-ocr is still inert and must warn.

    argparse cannot distinguish "user typed easyocr" from "default was used", so
    main() inspects argv directly. This regression test locks the path in.
    """
    _run_main_to_warning(
        ["--no-ocr", "--ocr-engine", "easyocr"], monkeypatch, caplog
    )
    warnings = [r.message for r in caplog.records if r.levelname == "WARNING"]
    assert any("--ocr-engine easyocr" in w for w in warnings), warnings


def test_no_ocr_no_warning_when_engine_left_default(monkeypatch, caplog):
    """`--no-ocr` without --ocr-engine does not falsely report easyocr as inert."""
    _run_main_to_warning(["--no-ocr"], monkeypatch, caplog)
    warnings = [r.message for r in caplog.records if r.levelname == "WARNING"]
    # No "--ocr-engine" mention because the user did not type it.
    assert not any("--ocr-engine" in w for w in warnings), warnings


def test_no_ocr_warns_when_ocr_lang_set(monkeypatch, caplog):
    """`--no-ocr --ocr-lang ko` warns that --ocr-lang has no effect."""
    _run_main_to_warning(["--no-ocr", "--ocr-lang", "ko"], monkeypatch, caplog)
    warnings = [r.message for r in caplog.records if r.levelname == "WARNING"]
    assert any("--ocr-lang" in w for w in warnings), warnings


def test_no_ocr_warns_when_psm_set(monkeypatch, caplog):
    """`--no-ocr --psm 6` warns that --psm has no effect."""
    _run_main_to_warning(["--no-ocr", "--psm", "6"], monkeypatch, caplog)
    warnings = [r.message for r in caplog.records if r.levelname == "WARNING"]
    assert any("--psm 6" in w for w in warnings), warnings


def test_no_ocr_alone_emits_no_warning(monkeypatch, caplog):
    """`--no-ocr` on its own does not warn — there are no inert flags to call out."""
    _run_main_to_warning(["--no-ocr"], monkeypatch, caplog)
    warnings = [
        r.message
        for r in caplog.records
        if r.levelname == "WARNING" and "no effect" in r.message
    ]
    assert warnings == []


# ---------- main() exits when engine prerequisites are missing ----------

def test_main_exits_when_tesseract_binary_missing(monkeypatch, caplog):
    """Selecting `--ocr-engine tesseract` without the binary on PATH exits at startup."""
    monkeypatch.setattr(
        "sys.argv", ["opendataloader-pdf-hybrid", "--ocr-engine", "tesseract"]
    )
    monkeypatch.setattr(hybrid_server, "_check_dependencies", lambda: None)
    monkeypatch.setattr(hybrid_server, "create_app", lambda **kwargs: object())
    monkeypatch.setattr("shutil.which", lambda _name: None)
    fake_uvicorn = type("FakeUvicorn", (), {"run": staticmethod(lambda *a, **k: None)})
    monkeypatch.setitem(__import__("sys").modules, "uvicorn", fake_uvicorn)

    caplog.set_level("ERROR", logger=hybrid_server.logger.name)
    with pytest.raises(SystemExit) as excinfo:
        hybrid_server.main()
    assert excinfo.value.code == 2
    errors = [r.message for r in caplog.records if r.levelname == "ERROR"]
    assert any("tesseract" in e.lower() for e in errors), errors


def test_main_skips_engine_check_when_no_ocr(monkeypatch, caplog):
    """`--no-ocr --ocr-engine tesseract` skips the binary check entirely."""
    called = {"which": False}

    def spy_which(_name):
        called["which"] = True
        return None  # Would fail the check if it were called.

    monkeypatch.setattr(
        "sys.argv",
        ["opendataloader-pdf-hybrid", "--no-ocr", "--ocr-engine", "tesseract"],
    )
    monkeypatch.setattr(hybrid_server, "_check_dependencies", lambda: None)
    monkeypatch.setattr(hybrid_server, "create_app", lambda **kwargs: object())
    monkeypatch.setattr("shutil.which", spy_which)
    fake_uvicorn = type("FakeUvicorn", (), {"run": staticmethod(lambda *a, **k: None)})
    monkeypatch.setitem(__import__("sys").modules, "uvicorn", fake_uvicorn)

    hybrid_server.main()  # must not raise SystemExit
    assert called["which"] is False