#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VisionAI Sistem Mimarisi
Ana sistem kontrolcü ve entegrasyon modülü
"""

import RPi.GPIO as GPIO
import cv2
import numpy as np
import tensorflow as tf
import pyttsx3
import speech_recognition as sr
import time
import threading
import queue
import logging
from datetime import datetime
from fpdf import FPDF
import os
import json

# Loglama yapılandırması
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('visionai.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

class VisionAI:
    """
    VisionAI Ana Sınıfı
    Tüm sistem bileşenlerini entegre eder ve kontrol eder
    """
    
    def __init__(self, config_file='config.json'):
        """
        VisionAI sistemini başlatır
        
        Args:
            config_file (str): Konfigürasyon dosyası yolu
        """
        self.config = self.load_config(config_file)
        self.setup_gpio()
        self.setup_camera()
        self.setup_ai_model()
        self.setup_voice_system()
        self.setup_database()
        
        # Sistem durumları
        self.running = True
        self.scanning = False
        self.classes = ['normal', 'miyop', 'hipermetrop', 'astigmat', 'kuru_goz']
        
        # Komut kuyruğu
        self.command_queue = queue.Queue()
        
        logger.info("VisionAI Sistemi Başlatıldı")
        self.set_system_status("ready")
    
    def load_config(self, config_file):
        """Konfigürasyon dosyasını yükler"""
        default_config = {
            "camera": {
                "width": 1920,
                "height": 1080,
                "fps": 30
            },
            "gpio": {
                "camera_pin": 18,
                "ir_sensor_pin": 19,
                "led_pin": 20,
                "microphone_pin": 21,
                "speaker_pin": 22
            },
            "ai": {
                "model_path": "models/visionai_eye_model.h5",
                "confidence_threshold": 0.7
            },
            "voice": {
                "rate": 150,
                "volume": 0.9,
                "language": "tr-TR"
            }
        }
        
        try:
            with open(config_file, 'r', encoding='utf-8') as f:
                config = json.load(f)
                # Varsayılan değerlerle birleştir
                for key, value in default_config.items():
                    if key not in config:
                        config[key] = value
        except FileNotFoundError:
            config = default_config
            # Varsayılan konfigürasyonu kaydet
            with open(config_file, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=4, ensure_ascii=False)
        
        return config
    
    def setup_gpio(self):
        """GPIO pinlerini yapılandırır"""
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        
        # Pinleri ayarla
        self.pins = self.config['gpio']
        
        for pin_name, pin_num in self.pins.items():
            if pin_name in ['camera_pin', 'ir_sensor_pin', 'led_pin', 'speaker_pin']:
                GPIO.setup(pin_num, GPIO.OUT)
                GPIO.output(pin_num, GPIO.LOW)
            elif pin_name == 'microphone_pin':
                GPIO.setup(pin_num, GPIO.IN)
        
        logger.info("GPIO pinleri yapılandırıldı")
    
    def setup_camera(self):
        """Kamerayı yapılandırır"""
        try:
            self.camera = cv2.VideoCapture(0)
            self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, self.config['camera']['width'])
            self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, self.config['camera']['height'])
            self.camera.set(cv2.CAP_PROP_FPS, self.config['camera']['fps'])
            
            if not self.camera.isOpened():
                raise Exception("Kamera açılamadı")
            
            logger.info("Kamera başarıyla yapılandırıldı")
        except Exception as e:
            logger.error(f"Kamera kurulum hatası: {e}")
            raise
    
    def setup_ai_model(self):
        """Yapay zeka modelini yükler"""
        try:
            model_path = self.config['ai']['model_path']
            if os.path.exists(model_path):
                self.model = tf.keras.models.load_model(model_path)
                logger.info(f"AI modeli yüklendi: {model_path}")
            else:
                logger.warning(f"Model dosyası bulunamadı: {model_path}")
                self.model = None
        except Exception as e:
            logger.error(f"Model yükleme hatası: {e}")
            self.model = None
    
    def setup_voice_system(self):
        """Ses sistemini yapılandırır"""
        try:
            # Sesli çıkış motoru
            self.engine = pyttsx3.init()
            self.engine.setProperty('rate', self.config['voice']['rate'])
            self.engine.setProperty('volume', self.config['voice']['volume'])
            
            # Türkçe sesi ayarla
            voices = self.engine.getProperty('voices')
            for voice in voices:
                if 'turkish' in voice.languages[0].lower():
                    self.engine.setProperty('voice', voice.id)
                    break
            
            # Sesli giriş tanıyıcı
            self.recognizer = sr.Recognizer()
            self.recognizer.energy_threshold = 300
            self.recognizer.pause_threshold = 0.8
            
            logger.info("Ses sistemi yapılandırıldı")
        except Exception as e:
            logger.error(f"Ses sistemi kurulum hatası: {e}")
    
    def setup_database(self):
        """Veritabanını yapılandırır"""
        self.db_path = "visionai.db"
        # Veritabanı işlemleri burada yapılacak
        logger.info("Veritabanı yapılandırıldı")
    
    def set_system_status(self, status):
        """Sistem durumunu ayarlar"""
        led_pin = self.pins['led_pin']
        
        if status == "ready":
            GPIO.output(led_pin, GPIO.HIGH)
        elif status == "scanning":
            # Yanıp sönme efekti
            for _ in range(3):
                GPIO.output(led_pin, GPIO.HIGH)
                time.sleep(0.3)
                GPIO.output(led_pin, GPIO.LOW)
                time.sleep(0.3)
            GPIO.output(led_pin, GPIO.HIGH)
        elif status == "error":
            # Hata efekti (hızlı yanıp sönme)
            for _ in range(5):
                GPIO.output(led_pin, GPIO.HIGH)
                time.sleep(0.1)
                GPIO.output(led_pin, GPIO.LOW)
                time.sleep(0.1)
        else:
            GPIO.output(led_pin, GPIO.LOW)
        
        logger.info(f"Sistem durumu: {status}")
    
    def run(self):
        """Ana sistem döngüsü"""
        try:
            self.speak("VisionAI sistemine hoş geldiniz. Lütfen gözünüzü tarayıcıya yerleştirin.")
            
            # Arka planda sesli dinlemeyi başlat
            listen_thread = threading.Thread(target=self.background_listener, daemon=True)
            listen_thread.start()
            
            # Ana döngü
            while self.running:
                # Komut kuyruğunu kontrol et
                if not self.command_queue.empty():
                    command = self.command_queue.get()
                    self.process_command(command)
                
                # Sistem durumunu kontrol et
                time.sleep(0.1)
                
        except KeyboardInterrupt:
            logger.info("Kullanıcı tarafından durduruldu")
            self.running = False
        except Exception as e:
            logger.error(f"Ana döngü hatası: {e}")
            self.set_system_status("error")
        finally:
            self.cleanup()
    
    def background_listener(self):
        """Arka planda sürekli sesli dinleme"""
        with sr.Microphone() as source:
            # Ortam gürültüsünü ayarla
            self.recognizer.adjust_for_ambient_noise(source, duration=1)
            logger.info("Ortam gürültüsü ayarlandı")
            
            while self.running:
                try:
                    # Ses dinle
                    audio = self.recognizer.listen(source, timeout=1, phrase_time_limit=5)
                    
                    # Konuşmayı tanı
                    try:
                        command = self.recognizer.recognize_google(
                            audio, 
                            language=self.config['voice']['language']
                        )
                        logger.info(f"Tanınan komut: {command}")
                        
                        # Komutu kuyruğa ekle
                        self.command_queue.put(command.lower())
                        
                    except sr.UnknownValueError:
                        # Anlaşılamayan konuşma
                        pass
                    except sr.RequestError as e:
                        logger.error(f"Google Speech Recognition servisi hatası: {e}")
                
                except sr.WaitTimeoutError:
                    # Zaman aşımı, devam et
                    pass
                except Exception as e:
                    logger.error(f"Dinleme hatası: {e}")
                    time.sleep(1)
    
    def process_command(self, command):
        """Sesli komutu işler"""
        logger.info(f"Komut işleniyor: {command}")
        
        if any(word in command for word in ["başlat", "start", "tara", "scan"]):
            self.start_scan()
        elif any(word in command for word in ["dur", "stop", "kapat", "exit"]):
            self.running = False
            self.speak("Sistem kapatılıyor.")
        elif any(word in command for word in ["yardım", "help", "nasıl"]):
            self.provide_help()
        elif any(word in command for word in ["teşekkür", "thanks", "sağol"]):
            self.speak("Rica ederim.")
        elif any(word in command for word in ["görüşürüz", "bye", "hoşça kal"]):
            self.speak("Görüşürüz.")
            self.running = False
        else:
            self.speak("Anlaşılamayan komut. Lütfen tekrar deneyin veya yardım için yardım deyin.")
    
    def start_scan(self):
        """Tarama sürecini başlatır"""
        if self.scanning:
            self.speak("Zaten bir tarama devam ediyor.")
            return
        
        self.scanning = True
        self.set_system_status("scanning")
        self.speak("Tarama başlıyor. Lütfen kıpırdamayın.")
        
        try:
            # Kamerayı aktif et
            GPIO.output(self.pins['camera_pin'], GPIO.HIGH)
            
            # IR sensörü ayarla
            self.set_ir_intensity(75)
            
            # Göz görüntüsü yakala
            ret, frame = self.camera.read()
            if ret:
                # Göz bölgesini tespit et
                eye_region = self.detect_eye_region(frame)
                
                if eye_region is not None:
                    # Analiz yap
                    result = self.analyze_eye(eye_region)
                    
                    # Sonuçları sesli olarak bildir
                    self.report_results(result)
                else:
                    self.speak("Göz tespit edilemedi. Lütfen tekrar deneyin.")
            else:
                self.speak("Kamera hatası. Lütfen bağlantıları kontrol edin.")
            
        except Exception as e:
            logger.error(f"Tarama hatası: {e}")
            self.speak("Tarama sırasında bir hata oluştu.")
            self.set_system_status("error")
        finally:
            # Kamerayı devre dışı bırak
            GPIO.output(self.pins['camera_pin'], GPIO.LOW)
            GPIO.output(self.pins['ir_sensor_pin'], GPIO.LOW)
            self.set_system_status("ready")
            self.scanning = False
    
    def detect_eye_region(self, frame):
        """Göz bölgesini tespit eder"""
        try:
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            
            # Haar cascade ile göz tespiti
            eye_cascade = cv2.CascadeClassifier(
                cv2.data.haarcascades + 'haarcascade_eye.xml'
            )
            eyes = eye_cascade.detectMultiScale(gray, 1.3, 5)
            
            if len(eyes) > 0:
                # En büyük göz bölgesini al
                largest_eye = max(eyes, key=lambda x: x[2] * x[3])
                x, y, w, h = largest_eye
                return frame[y:y+h, x:x+w]
            
            return None
        except Exception as e:
            logger.error(f"Göz tespiti hatası: {e}")
            return None
    
    def analyze_eye(self, eye_image):
        """Göz görüntüsünü analiz eder"""
        if self.model is None:
            logger.warning("AI modeli yüklenmedi, simülasyon sonuçları döndürülüyor")
            # Simülasyon sonuçları
            return {
                'condition': 'normal',
                'confidence': 0.85,
                'details': {
                    'description': 'Gözler normal görünüyor',
                    'recommendation': 'Düzenli kontrol önerilir',
                    'severity': 'low'
                }
            }
        
        try:
            # Görüntüyü ön işle
            processed_image = self.preprocess_image(eye_image)
            
            # Tahmin yap
            predictions = self.model.predict(processed_image)
            predicted_class_idx = np.argmax(predictions[0])
            predicted_class = self.classes[predicted_class_idx]
            confidence = float(predictions[0][predicted_class_idx])
            
            # Ek analizler
            additional_info = self.extract_additional_features(eye_image)
            
            result = {
                'condition': predicted_class,
                'confidence': confidence,
                'additional_info': additional_info,
                'details': self.get_condition_details(predicted_class)
            }
            
            logger.info(f"Analiz sonucu: {result}")
            return result
            
        except Exception as e:
            logger.error(f"Analiz hatası: {e}")
            return {
                'condition': 'error',
                'confidence': 0.0,
                'details': {
                    'description': 'Analiz sırasında hata oluştu',
                    'recommendation': 'Lütfen tekrar deneyin',
                    'severity': 'high'
                }
            }
    
    def preprocess_image(self, image):
        """Görüntüyü modele uygun hale getirir"""
        # Görüntüyü yeniden boyutlandır
        image = cv2.resize(image, (224, 224))
        
        # Gürültü azaltma
        image = cv2.GaussianBlur(image, (5, 5), 0)
        
        # Kontrast artırma
        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
        l, a, b = cv2.split(lab)
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
        l = clahe.apply(l)
        lab = cv2.merge((l, a, b))
        image = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
        
        # Normalizasyon
        image = image / 255.0
        
        # Batch boyutu ekle
        image = np.expand_dims(image, axis=0)
        
        return image
    
    def extract_additional_features(self, eye_image):
        """Görüntüden ek özellikler çıkarır"""
        gray = cv2.cvtColor(eye_image, cv2.COLOR_BGR2GRAY)
        
        # Gözbebeği tespiti
        circles = cv2.HoughCircles(
            gray, cv2.HOUGH_GRADIENT, dp=1, minDist=20,
            param1=50, param2=30, minRadius=10, maxRadius=50
        )
        
        pupil_info = {}
        if circles is not None:
            circles = np.uint16(np.around(circles))
            pupil_info = {
                'center': (int(circles[0][0][0]), int(circles[0][0][1])),
                'radius': int(circles[0][0][2])
            }
        
        # Göz kırpma analizi
        blink_rate = self.estimate_blink_rate(eye_image)
        
        # Kornea yansıması analizi
        corneal_reflection = self.analyze_corneal_reflection(eye_image)
        
        return {
            'pupil_info': pupil_info,
            'blink_rate': blink_rate,
            'corneal_reflection': corneal_reflection
        }
    
    def estimate_blink_rate(self, eye_image):
        """Göz kırpma oranını tahmin eder"""
        # Bu fonksiyon gerçek zamanlı video akışı için daha anlamlıdır
        # Statik görüntü için göz kapağının açık/kapalı durumunu döndürür
        gray = cv2.cvtColor(eye_image, cv2.COLOR_BGR2GRAY)
        
        # Göz kapağı tespiti için basit bir eşikleme
        _, thresh = cv2.threshold(gray, 45, 255, cv2.THRESH_BINARY_INV)
        
        # Göz kapağının kapalı olup olmadığını kontrol et
        closed = np.sum(thresh) / (thresh.shape[0] * thresh.shape[1]) > 0.3
        
        return "closed" if closed else "open"
    
    def analyze_corneal_reflection(self, eye_image):
        """Kornea yansımasını analiz eder"""
        gray = cv2.cvtColor(eye_image, cv2.COLOR_BGR2GRAY)
        
        # Parlak noktaları tespit et
        _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)
        contours, _ = cv2.findContours(
            thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
        )
        
        reflections = []
        for contour in contours:
            area = cv2.contourArea(contour)
            if area > 5:  # Gürültüyü filtrele
                M = cv2.moments(contour)
                if M["m00"] != 0:
                    cx = int(M["m10"] / M["m00"])
                    cy = int(M["m01"] / M["m00"])
                    reflections.append((cx, cy, area))
        
        return reflections
    
    def get_condition_details(self, condition):
        """Durum detaylarını döndürür"""
        details = {
            'normal': {
                'description': 'Gözler normal görünüyor',
                'recommendation': 'Düzenli kontrol önerilir',
                'severity': 'low'
            },
            'miyop': {
                'description': 'Miyopi (uzağı görme zorluğu) tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium'
            },
            'hipermetrop': {
                'description': 'Hipermetrop (yakını görme zorluğu) tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium'
            },
            'astigmat': {
                'description': 'Astigmatizma tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium'
            },
            'kuru_goz': {
                'description': 'Kuru göz sendromu belirtileri',
                'recommendation': 'Yapay gözyaşı kullanabilirsiniz',
                'severity': 'low'
            }
        }
        return details.get(condition, details['normal'])
    
    def report_results(self, result):
        """Sonuçları raporlar"""
        condition = result['condition']
        confidence = result['confidence']
        details = result['details']
        
        # Ana sonuç
        self.speak(f"Analiz tamamlandı. {confidence:.0f} oranında {condition} tespit edildi.")
        
        # Detaylı açıklama
        self.speak(details['description'])
        
        # Öneri
        self.speak(details['recommendation'])
        
        # Şiddet durumuna göre ek uyarı
        if details['severity'] == 'medium':
            self.speak("Bu durum bir göz doktoru tarafından değerlendirilmelidir.")
        
        # Rapor oluştur
        self.generate_report(result)
        
        # Veritabanına kaydet
        self.save_to_database(result)
    
    def generate_report(self, result):
        """PDF rapor oluşturur"""
        try:
            pdf = FPDF()
            pdf.add_page()
            pdf.set_font("Arial", size=12)
            
            # Başlık
            pdf.cell(200, 10, txt="VisionAI Göz Tarama Raporu", ln=1, align='C')
            pdf.ln(10)
            
            # Tarih
            pdf.cell(200, 10, txt=f"Tarih: {datetime.now().strftime('%d/%m/%Y %H:%M')}", ln=1)
            pdf.ln(10)
            
            # Sonuçlar
            pdf.cell(200, 10, txt=f"Durum: {result['condition']}", ln=1)
            pdf.cell(200, 10, txt=f"Güven: %{result['confidence']:.0f}", ln=1)
            pdf.ln(10)
            
            # Detaylar
            pdf.cell(200, 10, txt="Açıklama:", ln=1)
            pdf.multi_cell(0, 10, txt=result['details']['description'])
            pdf.ln(10)
            
            pdf.cell(200, 10, txt="Öneri:", ln=1)
            pdf.multi_cell(0, 10, txt=result['details']['recommendation'])
            
            # PDF'i kaydet
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"reports/visionai_report_{timestamp}.pdf"
            
            # Reports klasörü oluştur
            os.makedirs('reports', exist_ok=True)
            
            pdf.output(filename)
            
            self.speak(f"Raporunuz {filename} olarak kaydedildi.")
            logger.info(f"Rapor oluşturuldu: {filename}")
            
        except Exception as e:
            logger.error(f"Rapor oluşturma hatası: {e}")
            self.speak("Rapor oluşturulurken bir hata oluştu.")
    
    def save_to_database(self, result):
        """Sonuçları veritabanına kaydeder"""
        # Bu fonksiyon veritabanı entegrasyonu için hazırdır
        # SQLite kullanarak basit bir kayıt işlemi
        try:
            import sqlite3
            
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Tablo oluştur (yoksa)
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS scans (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                    condition TEXT,
                    confidence REAL,
                    details TEXT
                )
            ''')
            
            # Veriyi ekle
            cursor.execute('''
                INSERT INTO scans (condition, confidence, details)
                VALUES (?, ?, ?)
            ''', (
                result['condition'],
                result['confidence'],
                str(result['details'])
            ))
            
            conn.commit()
            conn.close()
            
            logger.info("Sonuçlar veritabanına kaydedildi")
            
        except Exception as e:
            logger.error(f"Veritabanı kayıt hatası: {e}")
    
    def set_ir_intensity(self, intensity):
        """IR ışık yoğunluğunu ayarlar (0-100)"""
        try:
            ir_pin = self.pins['ir_sensor_pin']
            
            # PWM ile yoğunluk kontrolü
            pwm = GPIO.PWM(ir_pin, 100)
            pwm.start(0)
            pwm.ChangeDutyCycle(intensity)
            time.sleep(0.1)
            pwm.stop()
            
            logger.info(f"IR yoğunluğu ayarlandı: {intensity}%")
            
        except Exception as e:
            logger.error(f"IR yoğunluk ayarlama hatası: {e}")
    
    def provide_help(self):
        """Yardım bilgisi sağlar"""
        help_text = """
        VisionAI Sistemi Komutları:
        
        - Başlat veya Tara: Taramayı başlatır
        - Dur veya Kapat: Sistemi kapatır
        - Yardım veya Nasıl: Bu yardım mesajını gösterir
        - Teşekkür: Teşekkür eder
        - Görüşürüz: Sistemden çıkış yapar
        
        Lütfen net bir şekilde konuşun.
        """
        self.speak("Yardım için kullanabileceğiniz komutlar:")
        self.speak("Başlat, taramayı başlatır.")
        self.speak("Dur, sistemi kapatır.")
        self.speak("Yardım, bu bilgiyi gösterir.")
    
    def speak(self, text):
        """Metni sesli olarak okur"""
        try:
            logger.info(f"Sesli çıktı: {text}")
            self.engine.say(text)
            self.engine.runAndWait()
        except Exception as e:
            logger.error(f"Sesli çıktı hatası: {e}")
    
    def cleanup(self):
        """Sistem kaynaklarını serbest bırakır"""
        try:
            if hasattr(self, 'camera'):
                self.camera.release()
            
            GPIO.cleanup()
            logger.info("VisionAI Sistemi Kapatıldı")
            
        except Exception as e:
            logger.error(f"Temizleme hatası: {e}")

# Ana program
if __name__ == "__main__":
    print("VisionAI Sistemi Başlatılıyor...")
    print("Ctrl+C ile durdurabilirsiniz.")
    
    try:
        vision_ai = VisionAI()
        vision_ai.run()
    except KeyboardInterrupt:
        print("\nProgram kullanıcı tarafından durduruldu.")
    except Exception as e:
        print(f"Program hatası: {e}")
    finally:
        if 'vision_ai' in locals():
            vision_ai.cleanup()
        print("Program sonlandırıldı.")

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VisionAI Göz Analiz Modülü
Yapay zeka modeli ve görüntü işleme algoritmaları
"""

import cv2
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential, Model, load_model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, GlobalAveragePooling2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.applications import MobileNetV2, EfficientNetB0
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau
import os
import json
import logging
from typing import Dict, Any, Tuple, List, Optional
from dataclasses import dataclass

logger = logging.getLogger(__name__)

@dataclass
class AnalysisResult:
    """Analiz sonucu veri sınıfı"""
    condition: str
    confidence: float
    additional_info: Dict[str, Any]
    details: Dict[str, Any]

class EyeAnalyzer:
    """
    Göz analizi sınıfı
    Görüntü işleme ve yapay zeka analizi yapar
    """
    
    def __init__(self, model_path: Optional[str] = None, config_path: str = 'config.json'):
        """
        Göz analizörünü başlatır
        
        Args:
            model_path (Optional[str]): Model dosya yolu
            config_path (str): Konfigürasyon dosyası yolu
        """
        self.config = self.load_config(config_path)
        self.classes = ['normal', 'miyop', 'hipermetrop', 'astigmat', 'kuru_goz']
        
        # Modeli yükle
        if model_path and os.path.exists(model_path):
            self.model = load_model(model_path)
            logger.info(f"Model yüklendi: {model_path}")
        else:
            self.model = self.create_model()
            logger.info("Yeni model oluşturuldu")
        
        # Görüntü işleme parametreleri
        self.image_size = (224, 224)
        self.confidence_threshold = self.config.get('ai', {}).get('confidence_threshold', 0.7)
        
        logger.info("Göz analizörü başlatıldı")
    
    def load_config(self, config_path: str) -> Dict[str, Any]:
        """Konfigürasyon dosyasını yükler"""
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            logger.warning(f"Konfigürasyon dosyası bulunamadı: {config_path}")
            return {}
    
    def create_model(self) -> Model:
        """
        Yeni bir yapay zeka modeli oluşturur
        
        Returns:
            Model: Oluşturulan Keras modeli
        """
        try:
            # Transfer learning ile EfficientNetB0 kullan
            base_model = EfficientNetB0(
                weights='imagenet',
                include_top=False,
                input_shape=(224, 224, 3)
            )
            
            # Taban katmanları dondur
            base_model.trainable = False
            
            # Yeni katmanlar ekle
            x = base_model.output
            x = GlobalAveragePooling2D()(x)
            x = Dense(256, activation='relu')(x)
            x = Dropout(0.5)(x)
            x = Dense(128, activation='relu')(x)
            x = Dropout(0.3)(x)
            predictions = Dense(len(self.classes), activation='softmax')(x)
            
            model = Model(inputs=base_model.input, outputs=predictions)
            
            # Modeli derle
            model.compile(
                optimizer=Adam(learning_rate=0.0001),
                loss='categorical_crossentropy',
                metrics=['accuracy', 'precision', 'recall']
            )
            
            logger.info("Yeni model oluşturuldu")
            return model
            
        except Exception as e:
            logger.error(f"Model oluşturma hatası: {e}")
            raise
    
    def train_model(self, train_dir: str, val_dir: str, epochs: int = 30, batch_size: int = 32):
        """
        Modeli eğitir
        
        Args:
            train_dir (str): Eğitim verileri dizini
            val_dir (str): Doğrulama verileri dizini
            epochs (int): Epoch sayısı
            batch_size (int): Batch boyutu
        """
        try:
            # Veri artırma
            train_datagen = ImageDataGenerator(
                rescale=1./255,
                rotation_range=20,
                width_shift_range=0.2,
                height_shift_range=0.2,
                shear_range=0.2,
                zoom_range=0.2,
                horizontal_flip=True,
                fill_mode='nearest',
                brightness_range=[0.8, 1.2],
                channel_shift_range=0.1
            )
            
            val_datagen = ImageDataGenerator(rescale=1./255)
            
            # Veri akışları
            train_generator = train_datagen.flow_from_directory(
                train_dir,
                target_size=self.image_size,
                batch_size=batch_size,
                class_mode='categorical'
            )
            
            validation_generator = val_datagen.flow_from_directory(
                val_dir,
                target_size=self.image_size,
                batch_size=batch_size,
                class_mode='categorical'
            )
            
            # Callback'ler
            callbacks = [
                ModelCheckpoint(
                    'models/best_model.h5',
                    monitor='val_accuracy',
                    save_best_only=True,
                    mode='max'
                ),
                EarlyStopping(
                    monitor='val_loss',
                    patience=10,
                    restore_best_weights=True
                ),
                ReduceLROnPlateau(
                    monitor='val_loss',
                    factor=0.1,
                    patience=5,
                    min_lr=1e-7
                )
            ]
            
            # Modeli eğit
            history = self.model.fit(
                train_generator,
                steps_per_epoch=train_generator.samples // batch_size,
                epochs=epochs,
                validation_data=validation_generator,
                validation_steps=validation_generator.samples // batch_size,
                callbacks=callbacks
            )
            
            # Modeli kaydet
            self.model.save('models/final_model.h5')
            logger.info("Model eğitildi ve kaydedildi")
            
            return history
            
        except Exception as e:
            logger.error(f"Model eğitme hatası: {e}")
            raise
    
    def preprocess_image(self, image: np.ndarray) -> np.ndarray:
        """
        Görüntüyü modele uygun hale getirir
        
        Args:
            image (np.ndarray): İşlenecek görüntü
            
        Returns:
            np.ndarray: İşlenmiş görüntü
        """
        try:
            # Görüntüyü yeniden boyutlandır
            image = cv2.resize(image, self.image_size)
            
            # Gürültü azaltma
            image = cv2.GaussianBlur(image, (5, 5), 0)
            
            # Kontrast artırma (CLAHE)
            lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
            l, a, b = cv2.split(lab)
            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
            l = clahe.apply(l)
            lab = cv2.merge((l, a, b))
            image = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
            
            # Normalizasyon
            image = image / 255.0
            
            # Batch boyutu ekle
            image = np.expand_dims(image, axis=0)
            
            return image
            
        except Exception as e:
            logger.error(f"Görüntü ön işleme hatası: {e}")
            raise
    
    def analyze_eye(self, eye_image: np.ndarray) -> AnalysisResult:
        """
        Göz görüntüsünü analiz eder
        
        Args:
            eye_image (np.ndarray): Analiz edilecek göz görüntüsü
            
        Returns:
            AnalysisResult: Analiz sonucu
        """
        try:
            # Görüntüyü ön işle
            processed_image = self.preprocess_image(eye_image)
            
            # Tahmin yap
            predictions = self.model.predict(processed_image)
            predicted_class_idx = np.argmax(predictions[0])
            predicted_class = self.classes[predicted_class_idx]
            confidence = float(predictions[0][predicted_class_idx])
            
            # Ek analizler
            additional_info = self.extract_additional_features(eye_image)
            
            # Sonucu oluştur
            result = AnalysisResult(
                condition=predicted_class,
                confidence=confidence,
                additional_info=additional_info,
                details=self.get_condition_details(predicted_class)
            )
            
            logger.info(f"Analiz sonucu: {result}")
            return result
            
        except Exception as e:
            logger.error(f"Analiz hatası: {e}")
            return AnalysisResult(
                condition='error',
                confidence=0.0,
                additional_info={},
                details={
                    'description': 'Analiz sırasında hata oluştu',
                    'recommendation': 'Lütfen tekrar deneyin',
                    'severity': 'high'
                }
            )
    
    def extract_additional_features(self, eye_image: np.ndarray) -> Dict[str, Any]:
        """
        Görüntüden ek özellikler çıkarır
        
        Args:
            eye_image (np.ndarray): İşlenecek görüntü
            
        Returns:
            Dict[str, Any]: Ek özellikler
        """
        try:
            gray = cv2.cvtColor(eye_image, cv2.COLOR_BGR2GRAY)
            
            # Gözbebeği tespiti
            pupil_info = self.detect_pupil(gray)
            
            # Göz kırpma analizi
            blink_rate = self.estimate_blink_rate(eye_image)
            
            # Kornea yansıması analizi
            corneal_reflection = self.analyze_corneal_reflection(gray)
            
            # Göz damarları analizi
            blood_vessels = self.analyze_blood_vessels(gray)
            
            return {
                'pupil_info': pupil_info,
                'blink_rate': blink_rate,
                'corneal_reflection': corneal_reflection,
                'blood_vessels': blood_vessels
            }
            
        except Exception as e:
            logger.error(f"Ek özellik çıkarma hatası: {e}")
            return {}
    
    def detect_pupil(self, gray_image: np.ndarray) -> Dict[str, Any]:
        """
        Gözbebeğini tespit eder
        
        Args:
            gray_image (np.ndarray): Gri tonlamalı görüntü
            
        Returns:
            Dict[str, Any]: Gözbebeği bilgileri
        """
        try:
            # Hough dairesel dönüşümü ile gözbebeği tespiti
            circles = cv2.HoughCircles(
                gray_image,
                cv2.HOUGH_GRADIENT,
                dp=1,
                minDist=20,
                param1=50,
                param2=30,
                minRadius=10,
                maxRadius=50
            )
            
            if circles is not None:
                circles = np.uint16(np.around(circles))
                # En büyük çemberi al
                largest_circle = max(circles, key=lambda x: x[2])
                x, y, r = largest_circle
                
                return {
                    'center': (int(x), int(y)),
                    'radius': int(r),
                    'diameter': int(r * 2),
                    'area': int(np.pi * r * r)
                }
            
            return {}
            
        except Exception as e:
            logger.error(f"Gözbebeği tespiti hatası: {e}")
            return {}
    
    def estimate_blink_rate(self, eye_image: np.ndarray) -> str:
        """
        Göz kırpma oranını tahmin eder
        
        Args:
            eye_image (np.ndarray): İşlenecek görüntü
            
        Returns:
            str: Göz durumu ("open" veya "closed")
        """
        try:
            gray = cv2.cvtColor(eye_image, cv2.COLOR_BGR2GRAY)
            
            # Göz kapağı tespiti için eşikleme
            _, thresh = cv2.threshold(gray, 45, 255, cv2.THRESH_BINARY_INV)
            
            # Göz kapağının kapalı olup olmadığını kontrol et
            closed_ratio = np.sum(thresh) / (thresh.shape[0] * thresh.shape[1])
            
            return "closed" if closed_ratio > 0.3 else "open"
            
        except Exception as e:
            logger.error(f"Göz kırpma analizi hatası: {e}")
            return "unknown"
    
    def analyze_corneal_reflection(self, gray_image: np.ndarray) -> List[Tuple[int, int, int]]:
        """
        Kornea yansımalarını analiz eder
        
        Args:
            gray_image (np.ndarray): Gri tonlamalı görüntü
            
        Returns:
            List[Tuple[int, int, int]]: Yansımaların listesi [(x, y, area)]
        """
        try:
            # Parlak noktaları tespit et
            _, thresh = cv2.threshold(gray_image, 200, 255, cv2.THRESH_BINARY)
            contours, _ = cv2.findContours(
                thresh,
                cv2.RETR_EXTERNAL,
                cv2.CHAIN_APPROX_SIMPLE
            )
            
            reflections = []
            for contour in contours:
                area = cv2.contourArea(contour)
                if area > 5:  # Gürültüyü filtrele
                    M = cv2.moments(contour)
                    if M["m00"] != 0:
                        cx = int(M["m10"] / M["m00"])
                        cy = int(M["m01"] / M["m00"])
                        reflections.append((cx, cy, int(area)))
            
            return reflections
            
        except Exception as e:
            logger.error(f"Kornea yansıması analizi hatası: {e}")
            return []
    
    def analyze_blood_vessels(self, gray_image: np.ndarray) -> Dict[str, Any]:
        """
        Göz damarlarını analiz eder
        
        Args:
            gray_image (np.ndarray): Gri tonlamalı görüntü
            
        Returns:
            Dict[str, Any]: Damar analizi sonuçları
        """
        try:
            # Kontrastı artır
            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
            enhanced = clahe.apply(gray_image)
            
            # Kenar tespiti
            edges = cv2.Canny(enhanced, 30, 100)
            
            # Morfolojik işlemler
            kernel = np.ones((3, 3), np.uint8)
            edges = cv2.dilate(edges, kernel, iterations=1)
            edges = cv2.erode(edges, kernel, iterations=1)
            
            # Damar yoğunluğunu hesapla
            vessel_density = np.sum(edges) / (edges.shape[0] * edges.shape[1])
            
            return {
                'vessel_density': float(vessel_density),
                'edge_count': int(np.sum(edges > 0))
            }
            
        except Exception as e:
            logger.error(f"Göz damarı analizi hatası: {e}")
            return {}
    
    def get_condition_details(self, condition: str) -> Dict[str, Any]:
        """
        Durum detaylarını döndürür
        
        Args:
            condition (str): Durum adı
            
        Returns:
            Dict[str, Any]: Durum detayları
        """
        details = {
            'normal': {
                'description': 'Gözler normal görünüyor',
                'recommendation': 'Düzenli kontrol önerilir',
                'severity': 'low',
                'medical_term': 'Normal'
            },
            'miyop': {
                'description': 'Miyopi (uzağı görme zorluğu) tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium',
                'medical_term': 'Myopia'
            },
            'hipermetrop': {
                'description': 'Hipermetrop (yakını görme zorluğu) tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium',
                'medical_term': 'Hyperopia'
            },
            'astigmat': {
                'description': 'Astigmatizma tespit edildi',
                'recommendation': 'Göz doktoruna başvurunuz',
                'severity': 'medium',
                'medical_term': 'Astigmatism'
            },
            'kuru_goz': {
                'description': 'Kuru göz sendromu belirtileri',
                'recommendation': 'Yapay gözyaşı kullanabilirsiniz',
                'severity': 'low',
                'medical_term': 'Dry Eye Syndrome'
            }
        }
        
        return details.get(condition, details['normal'])
    
    def batch_analyze(self, image_paths: List[str]) -> List[AnalysisResult]:
        """
        Birden fazla görüntüyü analiz eder
        
        Args:
            image_paths (List[str]): Görüntü yolları
            
        Returns:
            List[AnalysisResult]: Analiz sonuçları
        """
        results = []
        
        for image_path in image_paths:
            try:
                image = cv2.imread(image_path)
                if image is not None:
                    result = self.analyze_eye(image)
                    results.append(result)
                else:
                    logger.warning(f"Görüntü yüklenemedi: {image_path}")
            except Exception as e:
                logger.error(f"Batch analiz hatası - {image_path}: {e}")
        
        return results
    
    def export_results(self, results: List[AnalysisResult], output_path: str):
        """
        Analiz sonuçlarını dışa aktarır
        
        Args:
            results (List[AnalysisResult]): Analiz sonuçları
            output_path (str): Çıktı dosyası yolu
        """
        try:
            export_data = []
            for result in results:
                export_data.append({
                    'condition': result.condition,
                    'confidence': result.confidence,
                    'details': result.details,
                    'additional_info': result.additional_info
                })
            
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump(export_data, f, indent=4, ensure_ascii=False)
            
            logger.info(f"Sonuçlar dışa aktarıldı: {output_path}")
            
        except Exception as e:
            logger.error(f"Dışa aktarma hatası: {e}")
    
    def get_model_summary(self) -> str:
        """
        Model özetini döndürür
        
        Returns:
            str: Model özeti
        """
        try:
            summary = []
            self.model.summary(print_fn=lambda x: summary.append(x))
            return '\n'.join(summary)
        except Exception as e:
            logger.error(f"Model özeti hatası: {e}")
            return ""

# Test ve kullanım örnekleri
if __name__ == "__main__":
    # Loglama yapılandırması
    logging.basicConfig(level=logging.INFO)
    
    try:
        # Analizörü başlat
        analyzer = EyeAnalyzer()
        
        print("Göz Analizörü Testi")
        print("=" * 50)
        
        # Model özetini göster
        print("\nModel Özeti:")
        print(analyzer.get_model_summary())
        
        # Test görüntüsü yükle
        test_image_path = "test_images/eye_test.jpg"
        if os.path.exists(test_image_path):
            test_image = cv2.imread(test_image_path)
            if test_image is not None:
                # Analiz yap
                result = analyzer.analyze_eye(test_image)
                
                print(f"\nAnaliz Sonucu:")
                print(f"Durum: {result.condition}")
                print(f"Güven: %{result.confidence * 100:.1f}")
                print(f"Açıklama: {result.details['description']}")
                print(f"Öneri: {result.details['recommendation']}")
                print(f"Ek Bilgiler: {result.additional_info}")
            else:
                print("Test görüntüsü yüklenemedi")
        else:
            print(f"Test görüntüsü bulunamadı: {test_image_path}")
        
        print("\nTest tamamlandı.")
        
    except Exception as e:
        print(f"Test hatası: {e}")

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VisionAI Ses Sistemi Modülü
Sesli komut işleme ve geri bildirim
"""

import pyttsx3
import speech_recognition as sr
import threading
import queue
import time
import logging
import json
from typing import Dict, Any, Optional, Callable
from dataclasses import dataclass
from enum import Enum

logger = logging.getLogger(__name__)

class VoiceCommand(Enum):
    """Sesli komut numaralandırması"""
    START_SCAN = "başlat"
    STOP_SYSTEM = "dur"
    HELP = "yardım"
    THANKS = "teşekkür"
    GOODBYE = "görüşürüz"

@dataclass
class VoiceConfig:
    """Ses konfigürasyonu veri sınıfı"""
    rate: int = 150
    volume: float = 0.9
    language: str = "tr-TR"
    energy_threshold: int = 300
    pause_threshold: float = 0.8
    phrase_time_limit: float = 5.0
    timeout: float = 1.0

class VoiceSystem:
    """
    Ses sistemi sınıfı
    Sesli komut işleme ve metin seslendirme
    """
    
    def __init__(self, config: Optional[VoiceConfig] = None):
        """
        Ses sistemini başlatır
        
        Args:
            config (Optional[VoiceConfig]): Ses konfigürasyonu
        """
        self.config = config or VoiceConfig()
        
        # Sesli çıkış motoru
        self.engine = self._initialize_tts_engine()
        
        # Sesli giriş tanıyıcı
        self.recognizer = self._initialize_stt_recognizer()
        
        # Komut işleyiciler
        self.command_handlers: Dict[VoiceCommand, Callable] = {}
        
        # Komut kuyruğu
        self.command_queue = queue.Queue()
        
        # Durum değişkenleri
        self.listening = False
        self.speaking = False
        
        # Thread'ler
        self.speech_thread = None
        self.listen_thread = None
        
        logger.info("Ses sistemi başlatıldı")
    
    def _initialize_tts_engine(self) -> pyttsx3.engine.Engine:
        """Metin seslendirme motorunu başlatır"""
        try:
            engine = pyttsx3.init()
            
            # Motor özelliklerini ayarla
            engine.setProperty('rate', self.config.rate)
            engine.setProperty('volume', self.config.volume)
            
            # Türkçe sesi ayarla
            voices = engine.getProperty('voices')
            for voice in voices:
                if any('turkish' in lang.lower() for lang in voice.languages):
                    engine.setProperty('voice', voice.id)
                    break
            
            logger.info("TTS motoru başlatıldı")
            return engine
            
        except Exception as e:
            logger.error(f"TTS motoru başlatma hatası: {e}")
            raise
    
    def _initialize_stt_recognizer(self) -> sr.Recognizer:
        """Konuşma tanıma motorunu başlatır"""
        try:
            recognizer = sr.Recognizer()
            
            # Tanıyıcı özelliklerini ayarla
            recognizer.energy_threshold = self.config.energy_threshold
            recognizer.pause_threshold = self.config.pause_threshold
            recognizer.phrase_time_limit = self.config.phrase_time_limit
            recognizer.dynamic_energy_threshold = True
            
            logger.info("STT tanıyıcısı başlatıldı")
            return recognizer
            
        except Exception as e:
            logger.error(f"STT tanıyıcısı başlatma hatası: {e}")
            raise
    
    def register_command_handler(self, command: VoiceCommand, handler: Callable):
        """
        Komut işleyici kaydeder
        
        Args:
            command (VoiceCommand): Komut tipi
            handler (Callable): İşleyici fonksiyon
        """
        self.command_handlers[command] = handler
        logger.info(f"Komut işleyici kaydedildi: {command}")
    
    def start(self):
        """Ses sistemini başlatır"""
        try:
            # Konuşma thread'ini başlat
            self.speech_thread = threading.Thread(
                target=self._speech_worker,
                daemon=True
            )
            self.speech_thread.start()
            
            # Dinleme thread'ini başlat
            self.listen_thread = threading.Thread(
                target=self._listen_worker,
                daemon=True
            )
            self.listen_thread.start()
            
            logger.info("Ses sistemi başlatıldı")
            
        except Exception as e:
            logger.error(f"Ses sistemi başlatma hatası: {e}")
            raise
    
    def stop(self):
        """Ses sistemini durdurur"""
        try:
            self.listening = False
            self.speaking = False
            
            # Thread'leri bekle
            if self.speech_thread and self.speech_thread.is_alive():
                self.speech_thread.join(timeout=1)
            
            if self.listen_thread and self.listen_thread.is_alive():
                self.listen_thread.join(timeout=1)
            
            logger.info("Ses sistemi durduruldu")
            
        except Exception as e:
            logger.error(f"Ses sistemi durdurma hatası: {e}")
    
    def speak(self, text: str, blocking: bool = True):
        """
        Metni sesli olarak okur
        
        Args:
            text (str): Okunacak metin
            blocking (bool): Engelleme modu
        """
        try:
            logger.info(f"Sesli çıktı: {text}")
            
            if blocking:
                self.engine.say(text)
                self.engine.runAndWait()
            else:
                # Engellemesiz mod için kuyruğa ekle
                self.command_queue.put(('speak', text))
            
        except Exception as e:
            logger.error(f"Sesli okuma hatası: {e}")
    
    def start_listening(self):
        """Sesli dinlemeyi başlatır"""
        if not self.listening:
            self.listening = True
            logger.info("Sesli dinleme başlatıldı")
    
    def stop_listening(self):
        """Sesli dinlemeyi durdurur"""
        self.listening = False
        logger.info("Sesli dinleme durduruldu")
    
    def process_command(self, command: str):
        """
        Sesli komutu işler
        
        Args:
            command (str): İşlenecek komut
        """
        try:
            logger.info(f"Komut işleniyor: {command}")
            
            # Komutu normalize et
            normalized_command = command.lower().strip()
            
            # Komut tipini belirle
            voice_command = self._identify_command(normalized_command)
            
            if voice_command and voice_command in self.command_handlers:
                # İşleyiciyi çağır
                handler = self.command_handlers[voice_command]
                handler(command)
            else:
                # Bilinmeyen komut
                self.speak("Anlaşılamayan komut. Lütfen tekrar deneyin.")
            
        except Exception as e:
            logger.error(f"Komut işleme hatası: {e}")
            self.speak("Komut işlenirken bir hata oluştu.")
    
    def _identify_command(self, command: str) -> Optional[VoiceCommand]:
        """
        Komut tipini belirler
        
        Args:
            command (str): Komut metni
            
        Returns:
            Optional[VoiceCommand]: Komut tipi
        """
        command_keywords = {
            VoiceCommand.START_SCAN: ["başlat", "start", "tara", "scan", "başla"],
            VoiceCommand.STOP_SYSTEM: ["dur", "stop", "kapat", "exit", "bitir"],
            VoiceCommand.HELP: ["yardım", "help", "nasıl", "ne yap"],
            VoiceCommand.THANKS: ["teşekkür", "thanks", "sağol", "eyvallah"],
            VoiceCommand.GOODBYE: ["görüşürüz", "bye", "hoşça kal", "güle güle"]
        }
        
        for cmd_type, keywords in command_keywords.items():
            if any(keyword in command for keyword in keywords):
                return cmd_type
        
        return None
    
    def _speech_worker(self):
        """Konuşma işleyici worker thread'i"""
        while True:
            try:
                if not self.command_queue.empty():
                    item = self.command_queue.get()
                    
                    if item[0] == 'speak':
                        text = item[1]
                        self._speak_internal(text)
                
                time.sleep(0.1)
                
            except Exception as e:
                logger.error(f"Konuşma worker hatası: {e}")
                time.sleep(1)
    
    def _speak_internal(self, text: str):
        """Dahili metin seslendirme"""
        try:
            self.speaking = True
            self.engine.say(text)
            self.engine.runAndWait()
            self.speaking = False
        except Exception as e:
            logger.error(f"Dahili seslendirme hatası: {e}")
            self.speaking = False
    
    def _listen_worker(self):
        """Dinleme worker thread'i"""
        with sr.Microphone() as source:
            # Ortam gürültüsünü ayarla
            self.recognizer.adjust_for_ambient_noise(source, duration=1)
            logger.info("Ortam gürültüsü ayarlandı")
            
            while self.listening:
                try:
                    # Ses dinle
                    audio = self.recognizer.listen(
                        source,
                        timeout=self.config.timeout,
                        phrase_time_limit=self.config.phrase_time_limit
                    )
                    
                    # Konuşmayı tanı
                    try:
                        command = self.recognizer.recognize_google(
                            audio,
                            language=self.config.language
                        )
                        
                        logger.info(f"Tanınan komut: {command}")
                        
                        # Komutu işle
                        self.process_command(command)
                        
                    except sr.UnknownValueError:
                        # Anlaşılamayan konuşma
                        pass
                    except sr.RequestError as e:
                        logger.error(f"Google Speech Recognition servisi hatası: {e}")
                
                except sr.WaitTimeoutError:
                    # Zaman aşımı, devam et
                    pass
                except Exception as e:
                    logger.error(f"Dinleme hatası: {e}")
                    time.sleep(1)
    
    def set_voice_properties(self, rate: Optional[int] = None, volume: Optional[float] = None):
        """
        Ses özelliklerini ayarlar
        
        Args:
            rate (Optional[int]): Konuşma hızı
            volume (Optional[float]): Ses seviyesi
        """
        try:
            if rate is not None:
                self.engine.setProperty('rate', rate)
                self.config.rate = rate
            
            if volume is not None:
                self.engine.setProperty('volume', volume)
                self.config.volume = volume
            
            logger.info(f"Ses özellikleri güncellendi: rate={rate}, volume={volume}")
            
        except Exception as e:
            logger.error(f"Ses özellikleri ayarlama hatası: {e}")
    
    def available_voices(self) -> list:
        """
        Mevcut sesleri listeler
        
        Returns:
            list: Ses listesi
        """
        try:
            voices = self.engine.getProperty('voices')
            voice_list = []
            
            for i, voice in enumerate(voices):
                voice_info = {
                    'id': i,
                    'name': voice.name,
                    'languages': voice.languages,
                    'gender': voice.gender,
                    'age': voice.age
                }
                voice_list.append(voice_info)
            
            return voice_list
            
        except Exception as e:
            logger.error(f"Ses listeleme hatası: {e}")
            return []
    
    def set_voice(self, voice_id: int):
        """
        Ses kimliğini ayarlar
        
        Args:
            voice_id (int): Ses kimliği
        """
        try:
            voices = self.engine.getProperty('voices')
            if 0 <= voice_id < len(voices):
                self.engine.setProperty('voice', voices[voice_id].id)
                logger.info(f"Ses kimliği ayarlandı: {voice_id}")
            else:
                logger.warning(f"Geçersiz ses kimliği: {voice_id}")
                
        except Exception as e:
            logger.error(f"Ses kimliği ayarlama hatası: {e}")
    
    def save_config(self, config_path: str):
        """
        Konfigürasyonu kaydeder
        
        Args:
            config_path (str): Konfigürasyon dosyası yolu
        """
        try:
            config_data = {
                'rate': self.config.rate,
                'volume': self.config.volume,
                'language': self.config.language,
                'energy_threshold': self.config.energy_threshold,
                'pause_threshold': self.config.pause_threshold,
                'phrase_time_limit': self.config.phrase_time_limit,
                'timeout': self.config.timeout
            }
            
            with open(config_path, 'w', encoding='utf-8') as f:
                json.dump(config_data, f, indent=4, ensure_ascii=False)
            
            logger.info(f"Konfigürasyon kaydedildi: {config_path}")
            
        except Exception as e:
            logger.error(f"Konfigürasyon kaydetme hatası: {e}")
    
    def load_config(self, config_path: str):
        """
        Konfigürasyonu yükler
        
        Args:
            config_path (str): Konfigürasyon dosyası yolu
        """
        try:
            with open(config_path, 'r', encoding='utf-8') as f:
                config_data = json.load(f)
            
            self.config = VoiceConfig(**config_data)
            
            # Motor özelliklerini güncelle
            self.engine.setProperty('rate', self.config.rate)
            self.engine.setProperty('volume', self.config.volume)
            
            logger.info(f"Konfigürasyon yüklendi: {config_path}")
            
        except Exception as e:
            logger.error(f"Konfigürasyon yükleme hatası: {e}")
    
    def test_microphone(self):
        """Mikrofonu test eder"""
        try:
            with sr.Microphone() as source:
                self.recognizer.adjust_for_ambient_noise(source, duration=1)
                print("Mikrofon testi için konuşun...")
                
                audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=3)
                
                try:
                    text = self.recognizer.recognize_google(audio, language=self.config.language)
                    print(f"Tanınan: {text}")
                    return text
                except sr.UnknownValueError:
                    print("Anlaşılamadı")
                except sr.RequestError as e:
                    print(f"Hata: {e}")
                    
        except Exception as e:
            logger.error(f"Mikrofon testi hatası: {e}")
    
    def test_speakers(self):
        """Hoparlörleri test eder"""
        try:
            test_phrases = [
                "Hoparlör testi başlıyor.",
                "Bu bir test sesidir.",
                "Hoparlör testi tamamlandı."
            ]
            
            for phrase in test_phrases:
                self.speak(phrase)
                time.sleep(1)
                
        except Exception as e:
            logger.error(f"Hoparlör testi hatası: {e}")

# Test ve kullanım örnekleri
if __name__ == "__main__":
    # Loglama yapılandırması
    logging.basicConfig(level=logging.INFO)
    
    try:
        print("VisionAI Ses Sistemi Testi")
        print("=" * 50)
        
        # Ses sistemini başlat
        voice_system = VoiceSystem()
        
        # Komut işleyicileri kaydet
        def start_scan_handler(command):
            print(f"Tarama başlatma komutu: {command}")
            voice_system.speak("Tarama başlatılıyor.")
        
        def stop_system_handler(command):
            print(f"Sistem durdurma komutu: {command}")
            voice_system.speak("Sistem kapatılıyor.")
        
        def help_handler(command):
            print(f"Yardım komutu: {command}")
            help_text = """
            VisionAI Ses Komutları:
            - Başlat: Taramayı başlatır
            - Dur: Sistemi kapatır
            - Yardım: Bu bilgiyi gösterir
            - Teşekkür: Teşekkür eder
            - Görüşürüz: Sistemden çıkar
            """
            voice_system.speak(help_text)
        
        def thanks_handler(command):
            print(f"Teşekkür komutu: {command}")
            voice_system.speak("Rica ederim.")
        
        def goodbye_handler(command):
            print(f"Elveda komutu: {command}")
            voice_system.speak("Görüşürüz.")
        
        # Komut işleyicileri kaydet
        voice_system.register_command_handler(VoiceCommand.START_SCAN, start_scan_handler)
        voice_system.register_command_handler(VoiceCommand.STOP_SYSTEM, stop_system_handler)
        voice_system.register_command_handler(VoiceCommand.HELP, help_handler)
        voice_system.register_command_handler(VoiceCommand.THANKS, thanks_handler)
        voice_system.register_command_handler(VoiceCommand.GOODBYE, goodbye_handler)
        
        # Sistem başlat
        voice_system.start()
        
        # Mikrofon testi
        print("\nMikrofon Testi:")
        voice_system.test_microphone()
        
        # Hoparlör testi
        print("\nHoparlör Testi:")
        voice_system.test_speakers()
        
        # Mevcut sesleri listele
        print("\nMevcut Sesler:")
        voices = voice_system.available_voices()
        for i, voice in enumerate(voices):
            print(f"{i}: {voice['name']} ({voice['languages']})")
        
        # Dinlemeyi başlat
        print("\nSesli dinleme başlatıldı.")
        print("Komutlar: başlat, dur, yardım, teşekkür, görüşürüz")
        print("Testi durdurmak için Ctrl+C basın.")
        
        voice_system.start_listening()
        
        # Ana döngü
        try:
            while True:
                time.sleep(1)
                
        except KeyboardInterrupt:
            print("\nTest kullanıcı tarafından durduruldu.")
        finally:
            voice_system.stop()
            print("Test tamamlandı.")
        
    except Exception as e:
        print(f"Test hatası: {e}")