#!/usr/bin/env python3
"""
Compile results.tex using online LaTeX compilation API
No local LaTeX installation required.

Usage:
    python compile_latex_online.py [options] [file.tex]

Options:
    -v, --verbose    Show full error logs
    -s, --strict     Strict mode: fail on any errors or warnings
    --dry-run        Only run pre-flight checks, don't compile

API Usage Limits:
- latex.ytotech.com: No documented rate limits (experimental service)
- latexonline.cc: No documented limits, but may throttle heavy usage
"""

import requests
import json
import os
import sys
import re


def safe_print(text):
    """Print text, handling encoding issues on Windows."""
    try:
        print(text)
    except UnicodeEncodeError:
        print(text.encode('utf-8', errors='replace').decode('utf-8'))


def parse_error_logs(response_data):
    """Extract and format error logs from API response."""
    logs = []

    if isinstance(response_data, dict):
        if 'error' in response_data:
            logs.append(f"Error: {response_data['error']}")

        if 'logs' in response_data:
            for log in response_data['logs']:
                if isinstance(log, dict):
                    logs.append(f"[{log.get('type', 'log')}] {log.get('content', str(log))}")
                else:
                    logs.append(str(log))

        if 'log_files' in response_data:
            for name, content in response_data['log_files'].items():
                logs.append(f"\n=== {name} ===")
                logs.append(content[:10000] if len(content) > 10000 else content)

        if 'stdout' in response_data:
            logs.append(f"\n=== STDOUT ===\n{response_data['stdout']}")
        if 'stderr' in response_data:
            logs.append(f"\n=== STDERR ===\n{response_data['stderr']}")

    return logs


def extract_latex_errors(log_text):
    """Extract LaTeX error messages from log text."""
    errors = []
    warnings = []
    lines = log_text.split('\n') if isinstance(log_text, str) else []

    i = 0
    while i < len(lines):
        line = lines[i]

        # LaTeX errors start with !
        if line.startswith('!'):
            error_block = [line]
            for j in range(i + 1, min(i + 6, len(lines))):
                error_block.append(lines[j])
                if lines[j].startswith('l.'):  # Line number indicator
                    break
            errors.append('\n'.join(error_block))

        # LaTeX warnings
        elif 'Warning:' in line or 'warning:' in line:
            warnings.append(line.strip())

        # Overfull/Underfull box warnings
        elif line.startswith('Overfull') or line.startswith('Underfull'):
            warnings.append(line.strip())

        i += 1

    return errors, warnings


def check_latex_syntax(tex_content):
    """
    Pre-flight check for common LaTeX syntax errors.
    Returns: (errors: list, warnings: list)
    """
    errors = []
    warnings = []
    lines = tex_content.split('\n')

    # Track brace balance
    brace_count = 0

    # Track environments
    env_stack = []

    for i, line in enumerate(lines, 1):
        # Skip comments
        comment_pos = line.find('%')
        if comment_pos == 0:
            continue
        elif comment_pos > 0 and line[comment_pos-1] != '\\':
            line = line[:comment_pos]  # Only check non-comment part

        # Count braces
        for j, char in enumerate(line):
            if char == '{' and (j == 0 or line[j-1] != '\\'):
                brace_count += 1
            elif char == '}' and (j == 0 or line[j-1] != '\\'):
                brace_count -= 1

        # Check for command without backslash (common copy-paste error)
        unescaped_cmds = re.findall(r'(?<![\\a-zA-Z])(textbf|textit|emph|cite|ref|label|begin|end)\{', line)
        if unescaped_cmds:
            errors.append(f"Line {i}: Command without backslash: {unescaped_cmds}")
            safe_print(f"  -> {line.strip()[:80]}")

        # Check for malformed commands (e.g., \textbf{text textbf{more})
        if '\\textbf{' in line:
            # Count \textbf{ vs textbf{ (without backslash)
            proper = len(re.findall(r'\\textbf\{', line))
            improper = len(re.findall(r'(?<!\\)textbf\{', line))
            if improper > 0:
                errors.append(f"Line {i}: Malformed \\textbf command (missing backslash)")
                safe_print(f"  -> {line.strip()[:80]}")

        # Track environments
        for match in re.finditer(r'\\begin\{(\w+)\}', line):
            env_stack.append((match.group(1), i))
        for match in re.finditer(r'\\end\{(\w+)\}', line):
            env_name = match.group(1)
            if env_stack and env_stack[-1][0] == env_name:
                env_stack.pop()
            elif env_stack:
                errors.append(f"Line {i}: \\end{{{env_name}}} but expected \\end{{{env_stack[-1][0]}}} (opened at line {env_stack[-1][1]})")
            else:
                errors.append(f"Line {i}: \\end{{{env_name}}} without matching \\begin")

        # Check for quadruple backslashes
        if '\\\\\\\\' in line:
            errors.append(f"Line {i}: Quadruple backslash (should be \\\\)")

        # Check for unbalanced $ signs (math mode)
        dollar_count = len(re.findall(r'(?<!\\)\$', line))
        if dollar_count % 2 != 0:
            warnings.append(f"Line {i}: Odd number of $ signs (possible unbalanced math mode)")

        # Check for common table issues
        if '&' in line and '\\\\' in line:
            # Look for suspicious patterns like "} textbf{" without &
            if re.search(r'\}\s+\\?textbf\{', line):
                warnings.append(f"Line {i}: Possible missing & separator in table row")

    # Check final brace balance
    if brace_count != 0:
        errors.append(f"Document has unbalanced braces: {brace_count:+d} unclosed")

    # Check unclosed environments
    for env_name, line_num in env_stack:
        errors.append(f"Line {line_num}: \\begin{{{env_name}}} never closed")

    return errors, warnings


def compile_with_ytotech(tex_file, strict=False, verbose=False):
    """
    Compile LaTeX using latex.ytotech.com API

    In strict mode, requests error logs and fails if any errors found.

    Returns: (success: bool, pdf_path: str or None, errors: list, warnings: list)
    """
    print(f"Reading {tex_file}...")

    with open(tex_file, 'r', encoding='utf-8') as f:
        tex_content = f.read()

    # Pre-flight syntax check
    preflight_errors, preflight_warnings = check_latex_syntax(tex_content)

    if preflight_errors:
        print("\n=== Pre-flight ERRORS ===")
        for error in preflight_errors:
            safe_print(f"  ERROR: {error}")

    if preflight_warnings:
        print("\n=== Pre-flight Warnings ===")
        for warning in preflight_warnings:
            safe_print(f"  WARNING: {warning}")

    if preflight_errors:
        print()
        if strict:
            print("STRICT MODE: Aborting due to pre-flight errors.")
            return False, None, preflight_errors, preflight_warnings
        else:
            print("Continuing despite errors (use --strict to abort)...")

    print()

    api_url = "https://latex.ytotech.com/builds/sync"

    print("Sending to latex.ytotech.com API...")
    print("-" * 60)

    # Build payload - only include options that the API supports
    payload = {
        "compiler": "pdflatex",
        "resources": [
            {
                "main": True,
                "content": tex_content
            }
        ]
    }

    try:
        response = requests.post(
            api_url,
            json=payload,
            headers={'Content-Type': 'application/json'},
            timeout=180
        )

        content_type = response.headers.get('Content-Type', '')

        # Check if we got a PDF back
        is_pdf = response.content[:4] == b'%PDF' or 'application/pdf' in content_type

        if is_pdf:
            output_pdf = tex_file.replace('.tex', '.pdf')
            with open(output_pdf, 'wb') as f:
                f.write(response.content)

            print(f"PDF Created: {output_pdf}")
            print(f"Size: {len(response.content):,} bytes")

            # In strict mode with pre-flight errors, still fail
            if strict and preflight_errors:
                print("\nSTRICT MODE: PDF created but pre-flight errors were found.")
                print("Review and fix the errors above for a clean build.")
                return False, output_pdf, preflight_errors, preflight_warnings

            if preflight_warnings and verbose:
                print(f"\nNote: {len(preflight_warnings)} warning(s) found during pre-flight check.")

            print("\nSUCCESS: Compilation completed.")
            return True, output_pdf, [], preflight_warnings

        # No PDF - parse error response
        all_errors = list(preflight_errors)
        all_warnings = list(preflight_warnings)

        try:
            error_data = response.json()
            logs = parse_error_logs(error_data)

            for log in logs:
                latex_errors, latex_warnings = extract_latex_errors(log)

                if latex_errors:
                    print("\n=== LaTeX Compilation Errors ===")
                    for err in latex_errors[:15]:
                        safe_print(err)
                        print()
                    all_errors.extend([f"LaTeX: {e.split(chr(10))[0]}" for e in latex_errors])

                if latex_warnings and verbose:
                    print("\n=== LaTeX Warnings ===")
                    for warn in latex_warnings[:10]:
                        safe_print(f"  {warn}")
                    all_warnings.extend(latex_warnings)

            if not logs:
                all_errors.append(json.dumps(error_data, indent=2)[:3000])

        except json.JSONDecodeError:
            all_errors.append(response.text[:3000])

        print(f"\nCOMPILATION FAILED (Status: {response.status_code})")
        return False, None, all_errors, all_warnings

    except requests.exceptions.Timeout:
        return False, None, ["Request timed out after 3 minutes"], []
    except requests.exceptions.RequestException as e:
        return False, None, [f"Request failed: {e}"], []


def compile_with_latexonline(tex_file, strict=False):
    """
    Compile LaTeX using latexonline.cc API (fallback)

    Returns: (success: bool, pdf_path: str or None, errors: list, warnings: list)
    """
    print(f"Reading {tex_file}...")

    with open(tex_file, 'r', encoding='utf-8') as f:
        tex_content = f.read()

    api_url = "https://latexonline.cc/compile"

    print("Sending to latexonline.cc API...")
    print("-" * 60)

    try:
        response = requests.post(
            api_url,
            data={'text': tex_content},
            timeout=120
        )

        content_type = response.headers.get('Content-Type', '')

        if response.content[:4] == b'%PDF' or 'application/pdf' in content_type:
            output_pdf = tex_file.replace('.tex', '.pdf')
            with open(output_pdf, 'wb') as f:
                f.write(response.content)
            print(f"SUCCESS: Created {output_pdf}")
            print(f"Size: {len(response.content):,} bytes")
            return True, output_pdf, [], []

        # Parse error
        error_text = response.text[:5000]
        latex_errors, latex_warnings = extract_latex_errors(error_text)

        if latex_errors:
            print("\n=== LaTeX Errors Found ===")
            for err in latex_errors[:15]:
                safe_print(err)
                print()

        print(f"COMPILATION FAILED (Status: {response.status_code})")
        return False, None, latex_errors or [error_text], latex_warnings

    except requests.exceptions.Timeout:
        return False, None, ["Request timed out after 2 minutes"], []
    except requests.exceptions.RequestException as e:
        return False, None, [f"Request failed: {e}"], []


def save_error_log(tex_file, errors, warnings):
    """Save compilation errors and warnings to a log file."""
    log_file = tex_file.replace('.tex', '_errors.log')
    with open(log_file, 'w', encoding='utf-8') as f:
        f.write("LaTeX Compilation Report\n")
        f.write("=" * 60 + "\n\n")

        if errors:
            f.write(f"ERRORS ({len(errors)}):\n")
            f.write("-" * 40 + "\n")
            for error in errors:
                f.write(str(error) + "\n\n")

        if warnings:
            f.write(f"\nWARNINGS ({len(warnings)}):\n")
            f.write("-" * 40 + "\n")
            for warning in warnings:
                f.write(str(warning) + "\n")

    print(f"Error log saved to: {log_file}")
    return log_file


def print_usage():
    print(__doc__)


if __name__ == '__main__':
    tex_file = 'results.tex'
    verbose = False
    strict = False
    dry_run = False

    for arg in sys.argv[1:]:
        if arg in ['-h', '--help']:
            print_usage()
            sys.exit(0)
        elif arg in ['-v', '--verbose']:
            verbose = True
        elif arg in ['-s', '--strict']:
            strict = True
        elif arg == '--dry-run':
            dry_run = True
        elif not arg.startswith('-'):
            tex_file = arg

    if not os.path.exists(tex_file):
        print(f"ERROR: File not found: {tex_file}")
        sys.exit(1)

    print("=" * 60)
    print("Online LaTeX Compilation")
    print("=" * 60)

    mode_info = []
    if strict:
        mode_info.append("STRICT")
    if verbose:
        mode_info.append("VERBOSE")
    if dry_run:
        mode_info.append("DRY-RUN")

    if mode_info:
        print(f"Mode: {', '.join(mode_info)}")
    print()

    # Dry run - only pre-flight check
    if dry_run:
        print("Running pre-flight syntax check only...\n")
        with open(tex_file, 'r', encoding='utf-8') as f:
            tex_content = f.read()

        errors, warnings = check_latex_syntax(tex_content)

        if errors:
            print("=== ERRORS ===")
            for error in errors:
                safe_print(f"  {error}")

        if warnings:
            print("\n=== Warnings ===")
            for warning in warnings:
                safe_print(f"  {warning}")

        if not errors and not warnings:
            print("No issues found.")
            sys.exit(0)
        else:
            print(f"\nSummary: {len(errors)} error(s), {len(warnings)} warning(s)")
            sys.exit(1 if errors else 0)

    all_errors = []
    all_warnings = []

    # Try ytotech first
    print("Attempt 1: latex.ytotech.com")
    success, pdf_path, errors, warnings = compile_with_ytotech(tex_file, strict, verbose)
    all_errors.extend(errors)
    all_warnings.extend(warnings)

    if success:
        sys.exit(0)

    # Fallback to latexonline.cc
    print("\n" + "=" * 60)
    print("Attempt 2: latexonline.cc")
    success, pdf_path, errors, warnings = compile_with_latexonline(tex_file, strict)
    all_errors.extend(errors)
    all_warnings.extend(warnings)

    if success:
        sys.exit(0)

    # Both failed
    print("\n" + "=" * 60)
    print("COMPILATION FAILED")
    print("=" * 60)

    if all_errors:
        log_file = save_error_log(tex_file, all_errors, all_warnings)
        print(f"\nReview errors in: {log_file}")
        print("Fix the LaTeX issues and try again.")

    sys.exit(1)