"""Run the installed MarkItDown audio converter without installing dependencies.

Run from the repository root with tools/lab-venv/bin/python. Existing API
receipts and outputs are retained. This is an environment comparison, not a
comparison of two working speech recognizers.
"""
import hashlib
import importlib.metadata
import importlib.util
import inspect
import json
import platform
import sys
import time
from datetime import datetime
from pathlib import Path

sys.dont_write_bytecode = True
from markitdown import MarkItDown
from markitdown.converters import _audio_converter, _transcribe_audio

LAB = Path(__file__).resolve().parent
OUT = LAB / "markitdown"
OUT.mkdir(exist_ok=True)
SOURCE = LAB / "source"
SOURCE.mkdir(exist_ok=True)
for module, name in [(_audio_converter, "audio_converter-0.1.8.py"),
                     (_transcribe_audio, "transcribe_audio-0.1.8.py")]:
    (SOURCE / name).write_text(inspect.getsource(module), encoding="utf-8")

missing = [m for m in ("speech_recognition", "pydub")
           if importlib.util.find_spec(m) is None]
if not missing or _transcribe_audio._dependency_exc_info is None:
    raise RuntimeError("This bounded experiment requires the recorded missing audio dependencies")

records = []
inputs = []
for name, ext in [("speech", ".mp3"), ("screen-recording", ".mp4")]:
    src = LAB / "corpus" / (name + ext)
    t0 = time.perf_counter()
    result = MarkItDown(enable_plugins=False).convert_local(str(src))
    elapsed = round(time.perf_counter() - t0, 4)
    text = result.markdown
    (OUT / f"{name}.md").write_text(text, encoding="utf-8")
    diagnostic = ("conversion_returned: true\n"
                  f"markdown_text: {text!r}\n"
                  f"speech_dependencies: missing ({', '.join(missing)})\n")
    (OUT / f"{name}-diagnostic.md").write_text(diagnostic, encoding="utf-8")
    print(f"{name}: {diagnostic.strip()}; elapsed_s={elapsed}")
    records.append({"tool": "markitdown", "sample": name,
                    "output": f"markitdown/{name}.md", "elapsed_s": elapsed,
                    "error": None})
    inputs.append({"sample": name, "input": f"corpus/{src.name}",
                   "input_sha256": hashlib.sha256(src.read_bytes()).hexdigest(),
                   "output_chars": len(text), "missing_dependencies": missing,
                   "public_call": "MarkItDown(enable_plugins=False).convert_local(path)"})

runs_path = LAB / "runs.json"
runs = json.loads(runs_path.read_text(encoding="utf-8"))
runs["results"] = [r for r in runs["results"] if r["tool"] != "markitdown"] + records
runs["tools"]["markitdown"] = {
    "version": importlib.metadata.version("markitdown"), "device": "cpu",
    "elapsed_s": round(sum(r["elapsed_s"] for r in records), 4), "error": None,
    "audio_dependencies": "not installed", "missing_modules": missing,
    "plugins": False, "comparison_scope": "installed environment, not ASR accuracy"}
runs["date"] = datetime.now().astimezone().date().isoformat()
runs["python"] = platform.python_version()
runs_path.write_text(json.dumps(runs, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
(LAB / "audio-environment.json").write_text(json.dumps({
    "date": datetime.now().astimezone().isoformat(),
    "python": platform.python_version(), "platform": platform.platform(),
    "markitdown": importlib.metadata.version("markitdown"), "inputs": inputs,
    "scope": "No audio dependencies installed, no recognition network call, no model download"
}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")