import os
from pathlib import Path
from datetime import datetime
import json
import subprocess
import re

STORAGE_DIR = Path("/home/dayhanbiz/public_html/3-damja.science/storage")
EXCLUDED_DIRS = {
    STORAGE_DIR / "archive_originals",
    STORAGE_DIR / "duplicates",
    STORAGE_DIR / "history_vostlit",
    STORAGE_DIR / "corrupted"
}

PDFTOTEXT_BIN = "/bin/pdftotext"
if not Path(PDFTOTEXT_BIN).exists():
    PDFTOTEXT_BIN = "pdftotext"

try:
    from langdetect import detect, DetectorFactory
    DetectorFactory.seed = 0
    HAS_LANGDETECT = True
except ImportError:
    HAS_LANGDETECT = False

OLD_RUSSIAN_MARKERS = re.compile(r'[ѣѳіѵ]|(?:\b[а-яё]+(?:аго|яго)\b)|(?:\b[а-яёà-ÿa-z0-9]+ъ\b)', re.IGNORECASE)
LATIN_CHARS_PATTERN = re.compile(r'[a-zA-Z]')
EASTERN_SCRIPTS_PATTERN = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\u4E00-\u9FFF\u3040-\u309F\u30A0-\u30FF]')

def analyze_document_language(file_path: Path) -> str:
    ext = file_path.suffix.lower()
    if ext != '.pdf':
        if ext == '.txt':
            try:
                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    text = f.read(5000)
                    if not text.strip():
                        return "unknown"
                    words = text.split()
                    if not words:
                        return "unknown"
                    
                    old_matches = len(OLD_RUSSIAN_MARKERS.findall(text))
                    if (old_matches / len(words)) >= 0.05:
                        return "ru-pre1918"
                    
                    latin_count = len(LATIN_CHARS_PATTERN.findall(text))
                    if len(text) > 0 and (latin_count / len(text)) > 0.5:
                        return "en"
                        
                    eastern_count = len(EASTERN_SCRIPTS_PATTERN.findall(text))
                    if eastern_count >= 5:
                        return "eastern"
                        
                    return "ru"
            except Exception:
                pass
        return "unknown"

    valid_pages_text = []
    target_pages = [1, 2, 3]

    for page_num in target_pages:
        try:
            cmd = [PDFTOTEXT_BIN, '-f', str(page_num), '-l', str(page_num), '-q', str(file_path), '-']
            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=3)
            if result.returncode == 0 and result.stdout:
                page_content = result.stdout.strip()
                if page_content:
                    valid_pages_text.append(page_content)
        except Exception:
            continue
            
    if not valid_pages_text:
        return "unknown"

    combined_text = "\n".join(valid_pages_text)
    words = combined_text.split()
    total_words = len(words)
    
    if total_words < 3:
        return "unknown"

    old_matches_count = len(OLD_RUSSIAN_MARKERS.findall(combined_text))
    if (old_matches_count / total_words) >= 0.03 or old_matches_count >= 3:
        return "ru-pre1918"

    latin_chars_count = len(LATIN_CHARS_PATTERN.findall(combined_text))
    if len(combined_text) > 0 and (latin_chars_count / len(combined_text)) > 0.6:
        if HAS_LANGDETECT:
            try:
                lang = detect(combined_text[:2000])
                return lang
            except Exception:
                pass
        return "la-or-en"

    eastern_chars_count = len(EASTERN_SCRIPTS_PATTERN.findall(combined_text))
    if eastern_chars_count > 5:
        return "eastern"

    cyrillic_chars = sum(1 for c in combined_text if 'а' <= c.lower() <= 'я' or c.lower() == 'ё')
    if len(combined_text) > 0 and (cyrillic_chars / len(combined_text)) > 0.2:
        return "ru"

    if HAS_LANGDETECT:
        try:
            lang = detect(combined_text[:2000])
            if lang in ['ru', 'uk', 'bg', 'be']:
                return 'ru'
            return lang
        except Exception:
            pass

    return "ru"

def run_detector():
    print("=== Запуск отладочного детектора языков ===")
    print(f"Время: {datetime.now()}")
    print(f"Используется утилита pdftotext: {PDFTOTEXT_BIN}\n")

    sample_pdf = None
    for fp in STORAGE_DIR.rglob("*.pdf"):
        if not any(exc in fp.parents or exc == fp for exc in EXCLUDED_DIRS):
            sample_pdf = fp
            break
    
    if sample_pdf:
        print(f"Тестовый запуск pdftotext для файла: {sample_pdf.name}")
        test_cmd = [PDFTOTEXT_BIN, '-f', '1', '-l', '2', str(sample_pdf), '-']
        test_res = subprocess.run(test_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
        print(f"Код возврата test_res: {test_res.returncode}")
        print(f"Длина вывода stdout: {len(test_res.stdout)} символов")
        if len(test_res.stdout) > 0:
            print(f"Пример текста: {test_res.stdout[:150]}...\n")
        else:
            print(f"stderr (если есть): {test_res.stderr}\n")

    results = {}
    stats = {}

    for file_path in STORAGE_DIR.rglob("*"):
        if not file_path.is_file():
            continue

        if any(exc in file_path.parents or exc == file_path for exc in EXCLUDED_DIRS):
            continue

        ext = file_path.suffix.lower()
        if ext not in ['.pdf', '.txt', '.doc', '.docx']:
            continue

        rel_path = str(file_path.relative_to(STORAGE_DIR))
        lang = analyze_document_language(file_path)
        
        results[rel_path] = {
            "language": lang,
            "has_text_layer": lang != "unknown"
        }
        stats[lang] = stats.get(lang, 0) + 1

    report_path = STORAGE_DIR / "language_report.json"
    with open(report_path, 'w', encoding='utf-8') as f:
        json.dump(results, f, ensure_ascii=False, indent=2)

    print("=== Анализ завершен ===")
    print(f"Отчет сохранен в: {report_path}")
    print("Итоговая статистика по языкам:")
    for lang, c in stats.items():
        print(f"   - {lang}: {c} файлов")

if __name__ == "__main__":
    run_detector()