"""
CRANE AI - Kurulum Scripti
"""

import asyncio
import logging
import os
import sys
from pathlib import Path

# Logging ayarları
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class CRANESetup:
    """CRANE AI kurulum sınıfı"""
    
    def __init__(self):
        self.project_root = Path(__file__).parent
        self.required_dirs = [
            "logs",
            "models",
            "cache",
            "data",
            "exports"
        ]
        
    async def setup_system(self):
        """Sistemi kurar"""
        try:
            logger.info("🏗️  CRANE AI Kurulumu Başlatılıyor...")
            
            # Dizinleri oluştur
            await self._create_directories()
            
            # Paketleri kontrol et
            await self._check_packages()
            
            # Hugging Face token'ını kontrol et
            await self._check_hf_token()
            
            # Modelleri hazırla
            await self._prepare_models()
            
            # Test çalıştır
            await self._run_tests()
            
            logger.info("✅ CRANE AI Kurulumu Başarıyla Tamamlandı!")
            logger.info("🚀 Sistemi başlatmak için: python main.py")
            
        except Exception as e:
            logger.error(f"❌ Kurulum hatası: {str(e)}")
            sys.exit(1)
    
    async def _create_directories(self):
        """Gerekli dizinleri oluşturur"""
        logger.info("📁 Dizinler oluşturuluyor...")
        
        for dir_name in self.required_dirs:
            dir_path = self.project_root / dir_name
            dir_path.mkdir(exist_ok=True)
            logger.info(f"  ✅ {dir_name}/ oluşturuldu")
        
        # __init__.py dosyalarını oluştur
        init_files = [
            "core/__init__.py",
            "router/__init__.py",
            "memory/__init__.py",
            "config/__init__.py"
        ]
        
        for init_file in init_files:
            init_path = self.project_root / init_file
            init_path.parent.mkdir(exist_ok=True)
            if not init_path.exists():
                init_path.write_text('"""Package initialization"""')
                logger.info(f"  ✅ {init_file} oluşturuldu")
    
    async def _check_packages(self):
        """Gerekli paketleri kontrol eder"""
        logger.info("📦 Paketler kontrol ediliyor...")
        
        required_packages = [
            "torch",
            "transformers",
            "fastapi",
            "uvicorn",
            "gradio",
            "numpy",
            "requests",
            "psutil"
        ]
        
        missing_packages = []
        
        for package in required_packages:
            try:
                __import__(package)
                logger.info(f"  ✅ {package} mevcut")
            except ImportError:
                missing_packages.append(package)
                logger.warning(f"  ❌ {package} eksik")
        
        if missing_packages:
            logger.error(f"❌ Eksik paketler: {', '.join(missing_packages)}")
            logger.info("💡 Çözüm: pip install -r requirements.txt")
            raise Exception("Eksik paketler var")
    
    async def _check_hf_token(self):
        """Hugging Face token'ını kontrol eder"""
        logger.info("🔑 Hugging Face token kontrol ediliyor...")
        
        from config.settings import HF_TOKEN
        
        if not HF_TOKEN or HF_TOKEN == "YOUR_TOKEN_HERE":
            logger.error("❌ Hugging Face token bulunamadı")
            logger.info("💡 config/settings.py dosyasında HF_TOKEN'ı ayarlayın")
            raise Exception("Hugging Face token gerekli")
        
        # Token'ın geçerli olup olmadığını kontrol et
        try:
            from huggingface_hub import HfApi
            api = HfApi()
            user_info = api.whoami(token=HF_TOKEN)
            logger.info(f"  ✅ Token geçerli: {user_info.get('name', 'Unknown')}")
        except Exception as e:
            logger.error(f"❌ Token geçersiz: {str(e)}")
            raise Exception("Hugging Face token geçersiz")
    
    async def _prepare_models(self):
        """Modelleri hazırlar"""
        logger.info("🤖 Modeller hazırlanıyor...")
        
        from config.settings import MODELS, DEVICE
        
        # Cihaz bilgisini göster
        logger.info(f"  🖥️  Cihaz: {DEVICE}")
        
        # Model bilgilerini göster
        for model_name, model_config in MODELS.items():
            model_id = model_config["model_id"]
            logger.info(f"  📋 {model_name}: {model_id}")
            
            # Model cache'ini kontrol et
            cache_dir = self.project_root / "cache" / model_name
            cache_dir.mkdir(exist_ok=True)
        
        logger.info("  ✅ Modeller hazırlandı")
    
    async def _run_tests(self):
        """Basit testler çalıştırır"""
        logger.info("🧪 Testler çalıştırılıyor...")
        
        try:
            # Router testi
            from router.intelligent_router import IntelligentRouter
            logger.info("  ✅ Router importu başarılı")
            
            # Modül testleri
            from modules import CodeModule, ChatModule, ReasonModule, FastModule
            logger.info("  ✅ Modül importları başarılı")
            
            # Memory testi
            from memory.local_memory import LocalMemoryManager
            logger.info("  ✅ Memory Manager importu başarılı")
            
            # Token layer testi
            from core.token_capsule import TokenCapsuleLayer
            logger.info("  ✅ Token Capsule Layer importu başarılı")
            
            logger.info("  ✅ Tüm testler başarılı")
            
        except Exception as e:
            logger.error(f"❌ Test hatası: {str(e)}")
            raise Exception("Sistem testleri başarısız")

def main():
    """Ana kurulum fonksiyonu"""
    setup = CRANESetup()
    asyncio.run(setup.setup_system())

if __name__ == "__main__":
    main()