"""
The Lecturer's Stone - Standalone CLI.
Analyzes raw strings and documents (.docx, .xlsx, .pptx, .pdf, .txt, .md).
Inspects container metadata, detects generator signatures (openpyxl, python-docx, etc.),
and provides one-click sanitization or super-sanitization (nuke).
"""

import os
import sys
import argparse
import json
from pathlib import Path

# Add current directory to path
current_dir = Path(__file__).resolve().parent
if str(current_dir) not in sys.path:
    sys.path.insert(0, str(current_dir))

from document_parser import extract_text_from_file
from metadata_forensics import inspect_metadata, cleanse_metadata, DEFAULT_AUTHOR
sanitize_metadata = cleanse_metadata


def format_color_bar(probability: float, length: int = 24) -> str:
    filled = int(round(probability * length))
    empty = length - filled
    pct = round(probability * 100, 1)
    bar = "[" + "#" * filled + "-" * empty + f"] {pct}%"
    return bar


def print_metadata_section(meta: dict, action_note: str = None):
    print("\n" + "=" * 64)
    print(" THE LECTURER'S STONE - METADATA FORENSICS & CONTAINER")
    print("=" * 64)
    print(f"File:               {meta.get('file_name')} ({meta.get('file_type')})")

    all_auths = meta.get('all_authors', [])
    authors_str = ", ".join(all_auths) if all_auths else "[None / Stripped]"
    print(f"All Authors/Owners: {authors_str}")
    print(f"Primary Creator:    {meta.get('creator') or '[None / Stripped]'}")
    print(f"Last Modifier:      {meta.get('last_modified_by') or '[None / Stripped]'}")
    if meta.get('comment_authors'):
        print(f"Comment Authors:    {', '.join(meta['comment_authors'])}")
    if meta.get('contributors'):
        print(f"Contributors:       {', '.join(meta['contributors'])}")

    app_info = meta.get('application') or 'Unknown'
    if meta.get('app_version'):
        app_info += f" (v{meta.get('app_version')})"
    print(f"Application:        {app_info}")

    if meta.get('company'):
        print(f"Company:            {meta.get('company')}")
    if meta.get('manager'):
        print(f"Manager:            {meta.get('manager')}")

    created_str = meta.get('created_formatted') or meta.get('created') or '[None]'
    modified_str = meta.get('modified_formatted') or meta.get('modified') or '[None]'
    print(f"Created:            {created_str}")
    print(f"Modified:           {modified_str}")

    rev = meta.get('revision')
    edit_time = meta.get('total_edit_time_min')
    if rev or edit_time:
        rev_part = f"Rev {rev}" if rev else "Rev N/A"
        time_part = f"{edit_time} min edit time" if edit_time else "edit time N/A"
        print(f"Revision / Time:    {rev_part} | {time_part}")

    env_details = meta.get('environment_details', {})
    env_items = [f"{k}: {v}" for k, v in env_details.items() if k not in ["Application", "AppVersion", "Company", "Manager", "TotalTime"]]
    if env_items:
        print(f"Environment:        {', '.join(env_items[:3])}")

    risk = meta.get('risk_level', 'CLEAN')
    print(f"Forensic Risk:      [{risk}] {meta.get('verdict')}")
    clues = meta.get('clues', [])
    if clues:
        print("\nDetected Programmatic Clues:")
        for clue in clues:
            print(f" [!] {clue}")
    else:
        print("\nDetected Programmatic Clues: None (No automated generator fingerprints found)")

    if action_note:
        print("-" * 64)
        print(f"ACTION: {action_note}")

    print("=" * 64)


def main():
    parser = argparse.ArgumentParser(
        description="The Lecturer's Stone - Multi-Service AI Content Detection, Container Metadata Forensics, and Cleanser."
    )
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("-t", "--text", type=str, help="Plain text string to analyze.")
    group.add_argument(
        "-f", "--file", "--files",
        dest="files",
        nargs="+",
        help="Path(s) to document file(s), directory, or glob pattern (.txt, .md, .pdf, .docx, .xlsx, .pptx)."
    )

    # Metadata & Cleansing Options
    parser.add_argument("--cleanse", "--sanitize", dest="cleanse", nargs="?", const="", default=None, metavar="OUT_PATH",
                        help="Cleanse metadata (Creator/Modifier -> Author, preserves old creation date, cleans environment).")
    parser.add_argument("--author", type=str, default=DEFAULT_AUTHOR,
                        help=f"Author / Creator name to apply when cleansing (default: from LECTURERS_STONE_AUTHOR or '{DEFAULT_AUTHOR}').")
    parser.add_argument("--skip-ai", action="store_true",
                        help="Skip AI NLP model analysis (perform metadata inspection / cleansing only).")

    # AI Detection Options
    parser.add_argument("--json", action="store_true", help="Output results in JSON format.")
    parser.add_argument("--services", nargs="+", choices=["local_deberta", "szegedai", "radar", "fakespot", "yugamj", "piratexx", "heuristic"], help="Specific services to check (default: all active).")
    parser.add_argument("--export", type=str, default=None, help="Export detailed report to file (e.g. report.json).")

    args = parser.parse_args()

    # Collect files if provided
    SUPPORTED_EXTENSIONS = {
        ".txt", ".md", ".markdown", ".rtf", ".rst", ".py", ".json", ".csv",
        ".pdf", ".docx", ".doc", ".pptx", ".ppt", ".xlsx", ".xlsm", ".xltx"
    }

    if args.files:
        collected_paths = []
        for item in args.files:
            p = Path(item)
            if p.is_file():
                collected_paths.append(p)
            elif p.is_dir():
                for f in sorted(p.iterdir()):
                    if f.is_file() and f.suffix.lower() in SUPPORTED_EXTENSIONS and not f.name.startswith("~$") and not f.name.startswith("."):
                        collected_paths.append(f)
            else:
                # Try glob expansion
                import glob
                matched = glob.glob(item)
                if matched:
                    for m in sorted(matched):
                        mp = Path(m)
                        if mp.is_file() and mp.suffix.lower() in SUPPORTED_EXTENSIONS:
                            collected_paths.append(mp)
                else:
                    print(f"Error: File or path not found: '{item}'", file=sys.stderr)
                    sys.exit(1)

        if not collected_paths:
            print("Error: No supported document files found to process.", file=sys.stderr)
            sys.exit(1)

        is_batch = len(collected_paths) > 1
        reports = []

        from checker_hub import AICheckerHub
        hub = None if args.skip_ai else AICheckerHub()

        for idx, file_path in enumerate(collected_paths, 1):
            source_name = file_path.name
            ext = file_path.suffix.lower()
            meta_info = None
            action_note = None

            if ext in [".docx", ".xlsx", ".xlsm", ".pptx", ".pdf"]:
                try:
                    meta_info = inspect_metadata(file_path)
                except Exception as e:
                    meta_info = {"error": f"Failed to inspect metadata: {e}"}

            # Document Cleansing
            if args.cleanse is not None:
                if is_batch:
                    # In batch mode, if out_target is a directory, place cleansed files inside;
                    # otherwise default to <stem>_cleansed<ext> alongside original.
                    if args.cleanse and Path(args.cleanse).is_dir():
                        out_target = Path(args.cleanse) / f"{file_path.stem}_cleansed{file_path.suffix}"
                    else:
                        out_target = file_path.parent / f"{file_path.stem}_cleansed{file_path.suffix}"
                else:
                    out_target = Path(args.cleanse) if args.cleanse else None

                try:
                    saved_to = cleanse_metadata(file_path, output_path=out_target, author=args.author, keep_created_date=True)
                    action_note = f"Cleansed file written to: {saved_to} (Author: {args.author}, Old creation date preserved)"
                except Exception as e:
                    action_note = f"Error during metadata cleansing: {e}"

            if args.skip_ai:
                file_report = {
                    "source": source_name,
                    "file_path": str(file_path.resolve()),
                    "metadata_forensics": meta_info,
                    "action": action_note
                }
                reports.append(file_report)
                if not args.json:
                    if meta_info:
                        print_metadata_section(meta_info, action_note=action_note)
                    elif action_note:
                        print(f"[{source_name}] {action_note}")
                continue

            try:
                text = extract_text_from_file(file_path)
            except Exception as e:
                err_msg = f"Error extracting text from file '{file_path}': {e}"
                if is_batch:
                    print(err_msg, file=sys.stderr)
                    reports.append({
                        "source": source_name,
                        "file_path": str(file_path.resolve()),
                        "error": err_msg,
                        "metadata_forensics": meta_info,
                        "action": action_note
                    })
                    continue
                else:
                    print(err_msg, file=sys.stderr)
                    sys.exit(1)

            if not text.strip():
                empty_msg = f"Warning: Input text in '{file_path.name}' is empty."
                if is_batch:
                    print(empty_msg, file=sys.stderr)
                    reports.append({
                        "source": source_name,
                        "file_path": str(file_path.resolve()),
                        "warning": "Empty document text",
                        "metadata_forensics": meta_info,
                        "action": action_note
                    })
                    continue
                else:
                    print(f"Error: Input text is empty.", file=sys.stderr)
                    sys.exit(1)

            results = hub.analyze_text(text, services=args.services)
            results["source"] = source_name
            results["file_path"] = str(file_path.resolve())
            if meta_info:
                results["metadata_forensics"] = meta_info
            if action_note:
                results["action"] = action_note

            reports.append(results)

            if not args.json:
                if is_batch:
                    print(f"\n>>> Processing ({idx}/{len(collected_paths)}): {source_name}")
                if meta_info:
                    print_metadata_section(meta_info, action_note=action_note)

                print("\n" + "=" * 64)
                print(" THE LECTURER'S STONE - AI CONTENT CONSENSUS REPORT")
                print("=" * 64)
                print(f"Source:        {source_name}")
                print(f"Document Size: {results['document_stats']['words']} words | {results['document_stats']['characters']} characters")
                print("-" * 64)
                print(f"VERDICT:       {results['verdict'].upper()}")
                score_str = format_color_bar(results['consensus_ai_probability']) if results['consensus_ai_probability'] is not None else "N/A"
                print(f"AI SCORE:      {score_str}")
                print(f"SERVICE VOTES: {results['votes']['ai']} AI vs {results['votes']['human']} Human (out of {results['votes']['total_valid_services']} active services)")
                print(f"SCORE RANGE:   {results['score_spread']['min'] * 100:.1f}% to {results['score_spread']['max'] * 100:.1f}% (Spread: {results['score_spread']['range'] * 100:.1f}%)")
                print("-" * 64)
                print("INDIVIDUAL SERVICE BREAKDOWN:")
                for s in results["services"]:
                    s_name = s.get("service_name")
                    status = s.get("status")
                    prob = s.get("ai_probability")
                    label = s.get("label")
                    lat = s.get("latency_sec", 0.0)
                    if status == "success" and prob is not None:
                        bar = format_color_bar(prob, length=15)
                        print(f" * {s_name:<36} {bar} | {label} ({lat}s)")
                    else:
                        print(f" * {s_name:<36} [STATUS: {status}] ({lat}s)")
                print("=" * 64 + "\n")

        # Output handling for files (single vs batch)
        final_output = reports if is_batch else reports[0]
        if args.json:
            output_data = json.dumps(final_output, indent=2)
            print(output_data)

        if args.export:
            export_path = Path(args.export)
            export_path.write_text(json.dumps(final_output, indent=2), encoding="utf-8")
            print(f"Report saved to {export_path.resolve()}", file=sys.stderr)

        return

    # Plain text branch
    source_name = "Raw Text Input"
    text = args.text
    if not text.strip():
        print("Error: Input text is empty.", file=sys.stderr)
        sys.exit(1)

    from checker_hub import AICheckerHub
    hub = AICheckerHub()
    results = hub.analyze_text(text, services=args.services)
    results["source"] = source_name

    if args.json:
        output_data = json.dumps(results, indent=2)
        print(output_data)
        if args.export:
            Path(args.export).write_text(output_data, encoding="utf-8")
            print(f"\nReport exported to {args.export}", file=sys.stderr)
        return

    # Formatted terminal report for AI detection
    print("\n" + "=" * 64)
    print(" THE LECTURER'S STONE - AI CONTENT CONSENSUS REPORT")
    print("=" * 64)
    print(f"Source:        {source_name}")
    print(f"Document Size: {results['document_stats']['words']} words | {results['document_stats']['characters']} characters")
    print("-" * 64)
    print(f"VERDICT:       {results['verdict'].upper()}")
    score_str = format_color_bar(results['consensus_ai_probability']) if results['consensus_ai_probability'] is not None else "N/A"
    print(f"AI SCORE:      {score_str}")
    print(f"SERVICE VOTES: {results['votes']['ai']} AI vs {results['votes']['human']} Human (out of {results['votes']['total_valid_services']} active services)")
    print(f"SCORE RANGE:   {results['score_spread']['min'] * 100:.1f}% to {results['score_spread']['max'] * 100:.1f}% (Spread: {results['score_spread']['range'] * 100:.1f}%)")
    print("-" * 64)
    print("INDIVIDUAL SERVICE BREAKDOWN:")
    for s in results["services"]:
        s_name = s.get("service_name")
        status = s.get("status")
        prob = s.get("ai_probability")
        label = s.get("label")
        lat = s.get("latency_sec", 0.0)
        if status == "success" and prob is not None:
            bar = format_color_bar(prob, length=15)
            print(f" * {s_name:<36} {bar} | {label} ({lat}s)")
        else:
            print(f" * {s_name:<36} [STATUS: {status}] ({lat}s)")

    print("=" * 64 + "\n")

    if args.export:
        export_path = Path(args.export)
        export_path.write_text(json.dumps(results, indent=2), encoding="utf-8")
        print(f"Report saved to {export_path.resolve()}", file=sys.stderr)


if __name__ == "__main__":
    main()