#!/usr/bin/env python3
"""
Usta Assistant - Ana Asistan Servisi
====================================
Tüm modülleri birleştiren ana servis.

AKIŞ:
┌─────────────────────────────────────────────────────────────────┐
│ USTA: "jcb 330 bom silindir kaçırıyor"                          │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ 1. QUERY EXPANDER                                               │
│    - Yazım düzeltme: "bom" → "boom"                             │
│    - Sözlük çevirisi: TR → EN                                   │
│    - Sonuç: "boom cylinder leak"                                │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ 2. SMART SEARCH                                                 │
│    - Marka tespiti: JCB                                         │
│    - Model tespiti: 330                                         │
│    - Vektör arama + Filter                                      │
│    - Sonuç: JS330_SERVICE.pdf, Sayfa 850                        │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ 3. SAYFA GÖSTERİMİ                                              │
│    - PDF sayfası kullanıcıya gösterilir                         │
│    - Orijinal değerler görünür                                  │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ USTA SORUYOR: "bu sayfadaki basınç değeri ne?"                  │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ 4. VISION ANALYZER                                              │
│    - Soru İngilizceye çevrilir                                  │
│    - GPT-4o Vision ile analiz                                   │
│    - Cevap Türkçeye çevrilir                                    │
│    - Güvenlik uyarıları eklenir                                 │
└───────────────────────────┬─────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────────┐
│ USTA GÖRÜYOR:                                                   │
│ "Relief valve basıncı: 340 Bar (Şekil 3-2)                      │
│  ⚠️ DİKKAT: Ayar öncesi makineyi kapatın!"                     │
└─────────────────────────────────────────────────────────────────┘

Kullanım:
    from usta_assistant import UstaAssistant
    
    assistant = UstaAssistant()
    
    # Arama
    search_result = assistant.search("jcb 330 bom silindir kaçırıyor")
    
    # Sayfa analizi
    analysis = assistant.ask_about_page(
        pdf_path=search_result.results[0].pdf_path,
        page_number=search_result.results[0].page_number,
        question="basınç değeri ne?"
    )
"""

import os
import json
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, field

from query_expander import QueryExpander, ExpansionResult
from smart_search import SmartSearchService, SmartSearchResponse, SearchResult
from vision_analyzer import VisionAnalyzer, AnalysisResult


# ==================== CONFIGURATION ====================

# PDF mount path
PDF_MOUNT_PATH = os.getenv("PDF_MOUNT_PATH", "/mnt/pdfs")

# Qdrant
QDRANT_HOST = os.getenv("QDRANT_HOST", "10.10.10.25")
QDRANT_PORT = int(os.getenv("QDRANT_PORT", "6333"))

# Arama limitleri
DEFAULT_SEARCH_LIMIT = 5
MAX_SEARCH_LIMIT = 20


@dataclass
class ConversationContext:
    """Konuşma bağlamı - birden fazla soru için"""
    current_pdf: Optional[str] = None
    current_page: Optional[int] = None
    search_results: List[SearchResult] = field(default_factory=list)
    analysis_history: List[AnalysisResult] = field(default_factory=list)
    
    def set_page(self, pdf_path: str, page_number: int):
        self.current_pdf = pdf_path
        self.current_page = page_number
    
    def add_analysis(self, analysis: AnalysisResult):
        self.analysis_history.append(analysis)
        # Son 10 analizi tut
        if len(self.analysis_history) > 10:
            self.analysis_history = self.analysis_history[-10:]


class UstaAssistant:
    """
    Usta Asistan Ana Servisi
    
    Tüm modülleri birleştirir:
    - Query Expander (Türkçe → İngilizce)
    - Smart Search (Hibrit arama)
    - Vision Analyzer (Sayfa analizi)
    """
    
    def __init__(
        self,
        openai_api_key: str = None,
        qdrant_host: str = QDRANT_HOST,
        qdrant_port: int = QDRANT_PORT,
        dictionary_path: str = None,
        pdf_mount_path: str = PDF_MOUNT_PATH
    ):
        api_key = openai_api_key or os.getenv("OPENAI_API_KEY")
        if not api_key:
            raise ValueError("OPENAI_API_KEY gerekli!")
        
        # Servisleri başlat
        self.search_service = SmartSearchService(
            qdrant_host=qdrant_host,
            qdrant_port=qdrant_port,
            openai_api_key=api_key,
            dictionary_path=dictionary_path
        )
        
        self.vision_analyzer = VisionAnalyzer(
            openai_api_key=api_key,
            dictionary_path=dictionary_path,
            pdf_mount_path=pdf_mount_path
        )
        
        self.expander = self.search_service.expander
        self.pdf_mount_path = pdf_mount_path
        
        # Konuşma bağlamı
        self.context = ConversationContext()
        
        print("✓ Usta Assistant hazır!")
    
    def search(
        self,
        query: str,
        limit: int = DEFAULT_SEARCH_LIMIT
    ) -> SmartSearchResponse:
        """
        Arama yap ve sonuçları döndür.
        
        Args:
            query: Ustanın arama sorgusu (Türkçe)
            limit: Maksimum sonuç sayısı
            
        Returns:
            SmartSearchResponse
        """
        result = self.search_service.search(query, limit=limit)
        
        # Bağlamı güncelle
        self.context.search_results = result.results
        if result.results:
            top = result.results[0]
            self.context.set_page(top.pdf_path, top.page_number)
        
        return result
    
    def ask_about_page(
        self,
        question: str,
        pdf_path: str = None,
        page_number: int = None
    ) -> AnalysisResult:
        """
        Mevcut veya belirtilen sayfa hakkında soru sor.
        
        Args:
            question: Soru (Türkçe)
            pdf_path: PDF yolu (opsiyonel, yoksa bağlamdan alınır)
            page_number: Sayfa numarası (opsiyonel)
            
        Returns:
            AnalysisResult
        """
        # PDF ve sayfa bilgisi
        pdf = pdf_path or self.context.current_pdf
        page = page_number or self.context.current_page
        
        if not pdf or not page:
            return AnalysisResult(
                pdf_path="",
                page_number=0,
                original_question=question,
                translated_question="",
                answer="",
                answer_turkish="Önce bir arama yapın veya sayfa belirtin.",
                safety_warnings=[],
                referenced_items=[],
                confidence="low",
                error="PDF veya sayfa belirtilmedi"
            )
        
        # Analiz yap
        result = self.vision_analyzer.analyze_page(pdf, page, question)
        
        # Bağlamı güncelle
        self.context.add_analysis(result)
        
        return result
    
    def go_to_result(self, result_index: int = 0) -> Optional[SearchResult]:
        """
        Arama sonuçlarından birine git.
        
        Args:
            result_index: Sonuç indeksi (0-based)
            
        Returns:
            SearchResult veya None
        """
        if not self.context.search_results:
            print("⚠️ Önce bir arama yapın.")
            return None
        
        if result_index < 0 or result_index >= len(self.context.search_results):
            print(f"⚠️ Geçersiz indeks: {result_index} (0-{len(self.context.search_results)-1})")
            return None
        
        result = self.context.search_results[result_index]
        self.context.set_page(result.pdf_path, result.page_number)
        
        return result
    
    def get_pdf_path(self, relative_path: str) -> str:
        """Göreceli PDF yolunu tam yola çevir."""
        if os.path.isabs(relative_path):
            return relative_path
        return os.path.join(self.pdf_mount_path, relative_path)
    
    def get_context_summary(self) -> Dict:
        """Mevcut bağlamın özetini döndür."""
        return {
            "current_pdf": self.context.current_pdf,
            "current_page": self.context.current_page,
            "search_results_count": len(self.context.search_results),
            "analysis_history_count": len(self.context.analysis_history)
        }
    
    def reset_context(self):
        """Bağlamı sıfırla."""
        self.context = ConversationContext()
    
    def close(self):
        """Kaynakları temizle."""
        if self.search_service:
            self.search_service.close()
        if self.vision_analyzer:
            self.vision_analyzer.close()


# ==================== CLI INTERFACE ====================

def main():
    """İnteraktif CLI arayüzü"""
    import argparse
    
    parser = argparse.ArgumentParser(description="Usta Assistant")
    parser.add_argument("--no-vision", action="store_true", help="Vision özelliğini devre dışı bırak")
    args = parser.parse_args()
    
    # API Key kontrolü
    if not os.getenv("OPENAI_API_KEY"):
        print("❌ OPENAI_API_KEY ortam değişkeni ayarlanmalı!")
        print("   export OPENAI_API_KEY='sk-...'")
        return
    
    print("\n" + "=" * 70)
    print("   👷 USTA ASSISTANT")
    print("   İş makinası servis manueli asistanı")
    print("=" * 70)
    print()
    print("Komutlar:")
    print("  /ara <sorgu>     - Manuellerde arama yap")
    print("  /sor <soru>      - Mevcut sayfa hakkında soru sor")
    print("  /git <indeks>    - Arama sonucuna git (0,1,2...)")
    print("  /sayfa <no>      - Belirli bir sayfaya git")
    print("  /durum           - Mevcut durumu göster")
    print("  /sıfırla         - Bağlamı sıfırla")
    print("  /çıkış           - Çıkış")
    print()
    
    assistant = UstaAssistant()
    
    while True:
        try:
            user_input = input("\n👷 > ").strip()
            
            if not user_input:
                continue
            
            # Komut işleme
            if user_input.startswith("/"):
                parts = user_input.split(maxsplit=1)
                cmd = parts[0].lower()
                arg = parts[1] if len(parts) > 1 else ""
                
                if cmd in ["/çıkış", "/cikis", "/exit", "/q"]:
                    break
                
                elif cmd in ["/ara", "/search"]:
                    if not arg:
                        print("⚠️ Arama sorgusu gerekli: /ara <sorgu>")
                        continue
                    
                    print(f"🔍 Arıyorum: {arg}")
                    result = assistant.search(arg)
                    
                    print(f"\n📊 Sonuçlar ({result.total_found} sonuç, {result.search_time_ms}ms):")
                    print(f"   Marka: {result.analysis.brand or '-'}")
                    print(f"   Model: {result.analysis.model or '-'}")
                    print(f"   İngilizce: {result.expansion.english_terms[:5]}")
                    
                    print()
                    for i, r in enumerate(result.results):
                        marker = "→" if i == 0 else " "
                        print(f"   {marker} [{i}] {r.pdf_filename}")
                        print(f"        Sayfa: {r.page_number}, Skor: {r.score:.3f}")
                    
                    if result.results:
                        print(f"\n💡 İpucu: '/git 0' ile ilk sonuca gidin")
                
                elif cmd in ["/git", "/go"]:
                    try:
                        idx = int(arg) if arg else 0
                        r = assistant.go_to_result(idx)
                        if r:
                            print(f"✓ Gidilen sayfa: {r.pdf_filename}, Sayfa {r.page_number}")
                            print(f"💡 İpucu: '/sor <soru>' ile bu sayfa hakkında soru sorun")
                    except ValueError:
                        print("⚠️ Geçersiz indeks")
                
                elif cmd in ["/sayfa", "/page"]:
                    try:
                        page = int(arg)
                        if assistant.context.current_pdf:
                            assistant.context.current_page = page
                            print(f"✓ Sayfa: {page}")
                        else:
                            print("⚠️ Önce bir arama yapın")
                    except ValueError:
                        print("⚠️ Geçersiz sayfa numarası")
                
                elif cmd in ["/sor", "/ask"]:
                    if not arg:
                        print("⚠️ Soru gerekli: /sor <soru>")
                        continue
                    
                    if not assistant.context.current_pdf:
                        print("⚠️ Önce bir arama yapın ve sonuca gidin")
                        continue
                    
                    print(f"🔄 Analiz ediliyor...")
                    result = assistant.ask_about_page(arg)
                    
                    if result.error:
                        print(f"❌ Hata: {result.error}")
                    else:
                        print(f"\n{'=' * 60}")
                        print(f"📋 CEVAP (Güven: {result.confidence})")
                        print(f"{'=' * 60}")
                        print(result.answer_turkish)
                        
                        if result.safety_warnings:
                            print(f"\n⚠️ GÜVENLİK UYARILARI:")
                            for w in result.safety_warnings:
                                print(f"   • {w}")
                        
                        if result.referenced_items:
                            print(f"\n📎 Referanslar: {', '.join(result.referenced_items)}")
                
                elif cmd in ["/durum", "/status"]:
                    summary = assistant.get_context_summary()
                    print(f"\n📊 DURUM:")
                    print(f"   PDF: {summary['current_pdf'] or '-'}")
                    print(f"   Sayfa: {summary['current_page'] or '-'}")
                    print(f"   Arama Sonuçları: {summary['search_results_count']}")
                    print(f"   Analiz Geçmişi: {summary['analysis_history_count']}")
                
                elif cmd in ["/sıfırla", "/sifirla", "/reset"]:
                    assistant.reset_context()
                    print("✓ Bağlam sıfırlandı")
                
                else:
                    print(f"⚠️ Bilinmeyen komut: {cmd}")
                    print("   Yardım için: /ara, /sor, /git, /durum, /çıkış")
            
            else:
                # Komut değilse, soru olarak kabul et
                if assistant.context.current_pdf:
                    print(f"🔄 Sayfa hakkında soruluyor...")
                    result = assistant.ask_about_page(user_input)
                    
                    if result.error:
                        print(f"❌ Hata: {result.error}")
                    else:
                        print(f"\n📋 CEVAP:")
                        print(result.answer_turkish)
                else:
                    # Arama olarak kabul et
                    print(f"🔍 Arıyorum: {user_input}")
                    result = assistant.search(user_input)
                    
                    print(f"\n📊 Sonuçlar ({result.total_found}):")
                    for i, r in enumerate(result.results[:5]):
                        print(f"   [{i}] {r.pdf_filename} - Sayfa {r.page_number}")
                    
                    if result.results:
                        print(f"\n💡 '/git 0' ile sonuca gidin, sonra soru sorun")
        
        except KeyboardInterrupt:
            break
        except Exception as e:
            print(f"❌ Hata: {e}")
            import traceback
            traceback.print_exc()
    
    assistant.close()
    print("\n👋 Güle güle!")


if __name__ == "__main__":
    main()

