#!/usr/bin/env python3
"""
CLI interface for vue-docs-gen
Teljes funkcionalitás az eredeti run_generator.py alapján
"""

import argparse
import pathlib
import json
import sys
import subprocess
import time
import random
import os
import datetime
import shutil
import pyperclip

# Rich console imports
from rich.console import Console
from rich.progress import Progress, SpinnerColumn, TextColumn
from rich.panel import Panel
from rich.text import Text

# Selenium imports
import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains
from selenium.common.exceptions import TimeoutException, NoSuchElementException

console = Console()

def install_packages():
    """Automatikus package telepítés, mint az eredeti run_generator.py-ban"""
    packages = [
        "selenium>=4.0.0",
        "undetected-chromedriver>=3.4.0", 
        "rich>=13.0.0",
        "pyperclip>=1.8.0"
    ]
    
    console.print("📦 Ellenőrzöm a szükséges csomagokat...", style="blue")
    for package in packages:
        try:
            subprocess.check_call([
                sys.executable, "-m", "pip", "install", package
            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        except subprocess.CalledProcessError:
            console.print(f"❌ Hiba a {package} telepítésekor", style="red")

class HumanBehavior:
    """Emberi viselkedés szimulálása - eredeti implementáció"""
    
    @staticmethod
    def realistic_delay(min_sec=1.0, max_sec=3.0):
        delay = random.uniform(min_sec, max_sec)
        if random.random() < 0.3:
            delay += random.uniform(0.5, 2.0)
        time.sleep(delay)

    @staticmethod
    def human_mouse_movement(driver, element=None):
        """Emberi egér mozgás szimulálása"""
        actions = ActionChains(driver)
        if element:
            # Mozgás az elem közelébe
            actions.move_to_element_with_offset(element, 
                random.randint(-5, 5), random.randint(-5, 5))
        else:
            # Véletlenszerű mozgás
            actions.move_by_offset(random.randint(-50, 50), random.randint(-50, 50))
        
        actions.perform()
        HumanBehavior.realistic_delay(0.2, 0.8)

    @staticmethod
    def scroll_like_human(driver):
        """Emberi görgetés szimulálása"""
        for _ in range(random.randint(1, 3)):
            driver.execute_script(f"window.scrollBy(0, {random.randint(100, 300)});")
            HumanBehavior.realistic_delay(0.5, 1.5)

def clean_vue_code(code: str) -> str:
    """Vue kód tisztítása - eredeti implementáció"""
    lines = []
    for line in code.split('\n'):
        cleaned_line = line.rstrip()
        if cleaned_line.strip():
            lines.append(cleaned_line)
    
    cleaned_code = '\n'.join(lines)
    while '\n\n\n' in cleaned_code:
        cleaned_code = cleaned_code.replace('\n\n\n', '\n\n')
    
    return cleaned_code.strip()

def create_browser(config):
    """Chrome böngésző létrehozása - eredeti implementáció"""
    console.print("🌐 Chrome böngésző indítása...", style="blue")
    
    options = uc.ChromeOptions()
    if config.get("headless", False):
        options.headless = True
        console.print("👻 Headless mód bekapcsolva", style="yellow")
    
    options.add_argument("--window-size=1366,768")
    
    user_data_dir = config.get("chrome_user_data_dir")
    if user_data_dir:
        abs_path = pathlib.Path(user_data_dir).resolve()
        abs_path.mkdir(parents=True, exist_ok=True)
        options.add_argument(f"--user-data-dir={abs_path}")
        console.print(f"👤 Chrome profil: {abs_path}", style="blue")
    
    return uc.Chrome(options=options)

def send_to_merlin(driver, wait, vue_code, config):
    """Teljes Merlin AI interakció - eredeti implementáció"""
    
    # Navigálás Merlin oldalra
    merlin_url = config.get("merlin_site_url", "https://www.getmerlin.in/hu/chat")
    console.print(f"🤖 Navigálás: {merlin_url}", style="blue")
    driver.get(merlin_url)
    
    HumanBehavior.realistic_delay(3, 5)
    
    # Bejelentkezésre várás
    if not config.get("headless", False):
        console.print("⏳ [bold yellow]Jelentkezz be a Merlin-be, majd nyomj ENTER-t...[/bold yellow]")
        input()
    
    # Bot mention küldése
    input_selectors = config.get("merlin_input_selectors", [])
    textbox = None
    
    for selector in input_selectors:
        try:
            textbox = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
            console.print(f"✅ Textbox megtalálva: {selector}", style="green")
            break
        except TimeoutException:
            continue
    
    if not textbox:
        raise Exception("Nem találom a szövegdobozt!")
    
    # Bot mention
    mention = "@frontend_docs_generator"
    console.print(f"📝 Bot mention küldése: {mention}", style="blue")
    
    textbox.click()
    HumanBehavior.realistic_delay(1, 2)
    textbox.send_keys(mention)
    textbox.send_keys(Keys.ENTER)
    
    HumanBehavior.realistic_delay(2, 4)
    
    # Vue kód beillesztése
    console.print("📋 Vue kód beillesztése...", style="blue")
    
    # Újra textbox keresés
    for selector in input_selectors:
        try:
            textbox = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, selector)))
            break
        except TimeoutException:
            continue
    
    textbox.click()
    HumanBehavior.realistic_delay(0.5, 1)
    
    # Vue kód küldése részletekben
    lines = vue_code.split('\n')
    for i, line in enumerate(lines):
        textbox.send_keys(line)
        if i < len(lines) - 1:
            textbox.send_keys(Keys.SHIFT + Keys.ENTER)
        HumanBehavior.realistic_delay(0.1, 0.3)
    
    # Enter küldése
    HumanBehavior.realistic_delay(1, 2)
    textbox.send_keys(Keys.ENTER)
    
    console.print("⏳ Várakozás a bot válaszára...", style="yellow")
    
    # Válasz várakozás
    time.sleep(10)
    
    # Copy gomb keresés és válasz kinyerés
    copy_selector = config.get("merlin_copy_button_selector", "")
    response_content = ""
    
    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
        task = progress.add_task("🤖 Bot válasz feldolgozása...", total=None)
        
        try:
            # Copy gomb keresés
            copy_button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, copy_selector)))
            
            HumanBehavior.human_mouse_movement(driver, copy_button)
            copy_button.click()
            
            HumanBehavior.realistic_delay(1, 2)
            
            # Vágólap tartalom
            response_content = pyperclip.paste()
            
            if response_content and len(response_content.strip()) > 50:
                console.print("✅ Válasz sikeresen kimásolva a vágólapról!", style="green")
            else:
                raise Exception("Üres vagy túl rövid vágólap tartalom")
                
        except Exception as e:
            console.print(f"⚠️ Copy gomb hiba: {e}", style="yellow")
            console.print("🔄 Fallback: közvetlen szöveg kinyerés...", style="blue")
            
            # Fallback response kinyerés
            response_selectors = config.get("merlin_response_selectors", [])
            for selector in response_selectors:
                try:
                    response_elements = driver.find_elements(By.CSS_SELECTOR, selector)
                    if response_elements:
                        response_content = response_elements[-1].text  # Utolsó válasz
                        console.print("✅ Válasz megtalálva fallback módszerrel!", style="green")
                        break
                except:
                    continue
        
        progress.remove_task(task)
    
    return response_content

def clean_and_save_markdown(content: str, component_name: str, output_dir: pathlib.Path) -> pathlib.Path:
    """Markdown tisztítás és mentés - eredeti implementáció"""
    
    # Karakterek javítása
    replacements = {
        '"': '"', '"': '"', ''': "'", ''': "'",
        '—': '-', '–': '-', '…': '...',
        'â€™': "'", 'â€œ': '"', 'â€': '"'
    }
    
    for old, new in replacements.items():
        content = content.replace(old, new)
    
    # Fájlnév generálás
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    filename = f"{component_name}_docs_{timestamp}.md"
    
    output_path = output_dir / filename
    
    # Mentés UTF-8 encoding-gal
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(content)
    
    console.print(f"💾 Mentve: {output_path}", style="green")
    return output_path

def generate_documentation(vue_files: list, config: dict, output_dir: pathlib.Path):
    """Fő dokumentáció generálási folyamat"""
    
    if not vue_files:
        console.print("❌ Nincsenek feldolgozható Vue fájlok!", style="red")
        return
    
    console.print(Panel(f"🚀 Vue dokumentáció generálás\n📁 Kimeneti mappa: {output_dir}\n📝 Fájlok száma: {len(vue_files)}", 
                       title="Vue Docs Generator", style="blue"))
    
    # Browser indítás
    driver = create_browser(config)
    wait = WebDriverWait(driver, config.get("wait_timeout", 90))
    
    try:
        for i, vue_file in enumerate(vue_files, 1):
            console.print(f"\n📄 [{i}/{len(vue_files)}] Feldolgozás: {vue_file.name}", style="bold blue")
            
            # Vue kód olvasás és tisztítás
            try:
                vue_code = vue_file.read_text(encoding='utf-8')
                cleaned_code = clean_vue_code(vue_code)
                
                console.print(f"📝 Vue kód beolvasva: {len(cleaned_code)} karakter", style="blue")
                
                # Merlin AI interakció  
                response = send_to_merlin(driver, wait, cleaned_code, config)
                
                if response and len(response.strip()) > 50:
                    # Markdown mentés
                    component_name = vue_file.stem
                    saved_path = clean_and_save_markdown(response, component_name, output_dir)
                    
                    console.print(f"✅ Sikeres: {vue_file.name} → {saved_path.name}", style="green")
                else:
                    console.print(f"❌ Üres vagy hibás válasz: {vue_file.name}", style="red")
                
            except Exception as e:
                console.print(f"❌ Hiba {vue_file.name} feldolgozásakor: {e}", style="red")
                continue
            
            # Késleltetés a következő fájl előtt
            if i < len(vue_files):
                HumanBehavior.realistic_delay(5, 8)
                
    except KeyboardInterrupt:
        console.print("\n⏹️ Megszakítva a felhasználó által", style="yellow")
    except Exception as e:
        console.print(f"\n❌ Általános hiba: {e}", style="red")
    finally:
        console.print("\n🔒 Chrome böngésző bezárása...", style="blue")
        driver.quit()

def init_config():
    """Config.json létrehozása az aktuális mappában"""
    config_path = pathlib.Path.cwd() / "config.json"
    
    if config_path.exists():
        console.print(f"⚠️ A config.json már létezik: {config_path}", style="yellow")
        if input("Felülírjam? (y/N): ").lower() not in ['y', 'yes']:
            return
    
    # Default config
    default_config = {
        "merlin_site_url": "https://www.getmerlin.in/hu/chat",
        "chrome_user_data_dir": "./chrome_profile",
        "wait_timeout": 90,
        "headless": False,
        "merlin_input_selectors": [
            "textarea[placeholder*='üzenetet']",
            "textarea[data-id='root']",
            ".ProseMirror",
            "[contenteditable='true']"
        ],
        "merlin_response_selectors": [
            ".markdown-body",
            "[data-message-author-role='assistant']",
            ".message-content",
            ".response-text"
        ],
        "merlin_copy_button_selector": "button[aria-label*='Másolás'], button[title*='Copy'], .copy-button, button:has(svg[data-icon*='copy'])"
    }
    
    # Mentés
    with open(config_path, 'w', encoding='utf-8') as f:
        json.dump(default_config, f, indent=2, ensure_ascii=False)
    
    console.print(f"✅ Config létrehozva: {config_path}", style="green")
    console.print("📝 Szerkeszd a config.json fájlt szükség szerint!", style="blue")

def load_config(config_path=None):
    """Config betöltése"""
    if config_path:
        config_file = pathlib.Path(config_path)
    else:
        config_file = pathlib.Path.cwd() / "config.json"
    
    if not config_file.exists():
        console.print(f"❌ Config nem található: {config_file}", style="red")
        console.print("💡 Futtasd: vue-docs-gen init", style="blue")
        sys.exit(1)
    
    try:
        with open(config_file, encoding='utf-8') as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        console.print(f"❌ Hibás JSON a config fájlban: {e}", style="red")
        sys.exit(1)

def main():
    """Fő CLI entry point"""
    
    parser = argparse.ArgumentParser(
        description="🎉 Vue komponens dokumentáció generátor AI-val",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Példák:
  vue-docs-gen init                    Config létrehozása
  vue-docs-gen generate MyComponent.vue    Egyetlen komponens
  vue-docs-gen batch ./src/components/     Mappa feldolgozás
        """
    )
    
    subparsers = parser.add_subparsers(dest='command', help='Elérhető parancsok')
    
    # Init parancs
    parser_init = subparsers.add_parser('init', help='Config.json létrehozása')
    
    # Generate parancs  
    parser_gen = subparsers.add_parser('generate', help='Egyetlen Vue fájl dokumentálása')
    parser_gen.add_argument('file', help='Vue fájl útvonala')
    parser_gen.add_argument('--output', '-o', default='./generated_docs', 
                          help='Kimeneti mappa (default: ./generated_docs)')
    parser_gen.add_argument('--config', '-c', help='Egyéni config fájl')
    parser_gen.add_argument('--headless', action='store_true', 
                          help='Headless Chrome mód')
    
    # Batch parancs
    parser_batch = subparsers.add_parser('batch', help='Mappa feldolgozás')
    parser_batch.add_argument('folder', help='Vue komponenseket tartalmazó mappa')
    parser_batch.add_argument('--output', '-o', default='./generated_docs',
                            help='Kimeneti mappa (default: ./generated_docs)')
    parser_batch.add_argument('--config', '-c', help='Egyéni config fájl')
    parser_batch.add_argument('--headless', action='store_true',
                            help='Headless Chrome mód')
    
    # Version info
    parser.add_argument('--version', action='version', version='vue-docs-gen 0.2.0')
    
    args = parser.parse_args()
    
    # Ha nincs parancs megadva
    if not args.command:
        console.print("🎉 vue-docs-gen v0.2.0", style="bold blue")
        console.print("Vue komponens dokumentáció generátor", style="blue")
        parser.print_help()
        return
    
    # Package telepítés
    install_packages()
    
    # Init parancs
    if args.command == 'init':
        init_config()
        return
    
    # Config betöltése
    config = load_config(args.config)
    
    # Headless override
    if hasattr(args, 'headless') and args.headless:
        config['headless'] = True
    
    # Output mappa létrehozása
    output_dir = pathlib.Path(args.output)
    output_dir.mkdir(parents=True, exist_ok=True)
    
    # Generate parancs
    if args.command == 'generate':
        vue_file = pathlib.Path(args.file)
        if not vue_file.exists():
            console.print(f"❌ Fájl nem található: {vue_file}", style="red")
            sys.exit(1)
        
        if not vue_file.suffix.lower() == '.vue':
            console.print(f"❌ Nem Vue fájl: {vue_file}", style="red")
            sys.exit(1)
        
        generate_documentation([vue_file], config, output_dir)
    
    # Batch parancs
    elif args.command == 'batch':
        folder = pathlib.Path(args.folder)
        if not folder.exists() or not folder.is_dir():
            console.print(f"❌ Mappa nem található: {folder}", style="red")
            sys.exit(1)
        
        vue_files = list(folder.glob("*.vue"))
        if not vue_files:
            console.print(f"❌ Nincsenek Vue fájlok a mappában: {folder}", style="red")
            sys.exit(1)
        
        console.print(f"📁 {len(vue_files)} Vue fájl találva", style="blue")
        generate_documentation(vue_files, config, output_dir)

if __name__ == "__main__":
    main()