chatbot_backend.py

"""
Chatbot backend işlevselliği.
Bu modül, kullanıcı girdisini işleyen ve dinamik promptlar oluşturan ana mantığı içerir.
"""

import os
import json
from typing import Dict, Any, Tuple, List, Optional
import openai
from google import generativeai as genai
import requests
from dotenv import load_dotenv

# Prompt şablonlarını içe aktar
from prompt_templates import (
    PROMPT_CATEGORIES,
    predict_category,
    extract_parameters,
    create_prompt
)

# AI Prompt Generator'ı içe aktar
from ai_prompt_generator import AIPromptGenerator

# .env dosyasını yükle (varsa)
load_dotenv()

class PromptEngineerChatbot:
    """
    Prompt mühendisliği chatbot sınıfı.
    Bu sınıf, kullanıcı girdisini işleyerek dinamik promptlar oluşturur.
    """
    
    def __init__(self):
        """
        Chatbot'u başlat ve yapılandır.
        """
        self.conversation_history = []
        self.current_category = None
        self.current_params = None
        self.ai_generator = AIPromptGenerator()
        
    def process_input(self, user_input: str, use_ai_generation: bool = True, provider: str = "openai", model: Optional[str] = None) -> Tuple[str, str, Dict[str, Any]]:
        """
        Kullanıcı girdisini işler ve dinamik bir prompt oluşturur.
        
        Args:
            user_input (str): Kullanıcı girdisi
            use_ai_generation (bool): AI destekli prompt oluşturmayı kullan
            provider (str): AI sağlayıcısı ('openai', 'gemini', 'openrouter')
            model (str, optional): Kullanılacak model
            
        Returns:
            Tuple[str, str, Dict[str, Any]]: Oluşturulan prompt, kategori ve parametreler
        """
        # Kullanıcı girdisini kaydet
        self.conversation_history.append({"role": "user", "content": user_input})
        
        # Kategori tahmini
        category = predict_category(user_input)
        
        # Parametreleri çıkar
        params = extract_parameters(category, user_input)
        
        # Mevcut kategori ve parametreleri güncelle
        self.current_category = category
        self.current_params = params
        
        # AI destekli prompt oluşturma kullanılıyorsa
        if use_ai_generation:
            # Şablon tabanlı promptu oluştur (referans için)
            template_prompt = create_prompt(category, params)
            
            # Kategori bilgisini ve şablon promptu kullanarak daha spesifik bir AI prompt oluştur
            enhanced_user_input = f"""
            Kategori: {category}
            
            Kullanıcı İsteği: {user_input}
            
            Lütfen bu istek için çok detaylı ve spesifik bir prompt oluştur. 
            Şablon olarak aşağıdaki yapıyı kullanabilirsin, ancak içeriği tamamen kullanıcının isteğine göre özelleştir ve çok daha detaylı hale getir:
            
            {template_prompt}
            
            Önemli: Yukarıdaki şablonu olduğu gibi kullanma, sadece yapı referansı olarak kullan. 
            İçeriği tamamen kullanıcının isteğine özel olarak oluştur ve çok daha detaylı, spesifik bilgiler ekle.
            Örneğin, kullanıcı hava durumu uygulaması istiyorsa, hava durumu API'leri, hava verilerinin görselleştirilmesi, 
            hava tahminleri, konum takibi gibi spesifik detaylar ekle.
            """
            
            # AI destekli prompt oluştur
            result = self.ai_generator.generate_prompt(enhanced_user_input, provider, model)
            
            if result["success"]:
                prompt = result["prompt"]
            else:
                # AI prompt oluşturma başarısız olursa şablon promptu kullan
                prompt = template_prompt
        else:
            # Şablon tabanlı prompt oluştur
            prompt = create_prompt(category, params)
        
        # Chatbot yanıtını kaydet
        self.conversation_history.append({"role": "assistant", "content": prompt})
        
        return prompt, category, params
    
    def get_conversation_history(self) -> List[Dict[str, str]]:
        """
        Konuşma geçmişini döndürür.
        
        Returns:
            List[Dict[str, str]]: Konuşma geçmişi
        """
        return self.conversation_history
    
    def clear_conversation_history(self) -> None:
        """
        Konuşma geçmişini temizler.
        """
        self.conversation_history = []
        self.current_category = None
        self.current_params = None


class AIModelInterface:
    """
    Farklı AI API'leri için arayüz sınıfı.
    Bu sınıf, OpenAI, Google Gemini ve OpenRouter API'leri ile etkileşim sağlar.
    """
    
    def __init__(self):
        """
        AI model arayüzünü başlat.
        """
        self.api_keys = {
            "openai": os.getenv("OPENAI_API_KEY", ""),
            "gemini": os.getenv("GEMINI_API_KEY", ""),
            "openrouter": os.getenv("OPENROUTER_API_KEY", "")
        }
    
    def set_api_key(self, provider: str, api_key: str) -> None:
        """
        Belirli bir sağlayıcı için API anahtarını ayarlar.
        
        Args:
            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
            api_key (str): API anahtarı
        """
        if provider in self.api_keys:
            self.api_keys[provider] = api_key
    
    def get_available_models(self, provider: str) -> List[str]:
        """
        Belirli bir sağlayıcı için kullanılabilir modelleri döndürür.
        
        Args:
            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
            
        Returns:
            List[str]: Kullanılabilir modeller listesi
        """
        if provider == "openai":
            return ["gpt-4o", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"]
        elif provider == "gemini":
            return ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-1.0-pro"]
        elif provider == "openrouter":
            return [
                "openai/gpt-4o", 
                "openai/gpt-4-turbo", 
                "anthropic/claude-3-opus", 
                "anthropic/claude-3-sonnet",
                "google/gemini-1.5-pro",
                "meta-llama/llama-3-70b-instruct"
            ]
        return []
    
    def generate_with_openai(self, prompt: str, model: str = "gpt-3.5-turbo") -> str:
        """
        OpenAI API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            
        Returns:
            str: Oluşturulan yanıt
        """
        if not self.api_keys["openai"]:
            return "OpenAI API anahtarı ayarlanmamış."
        
        try:
            openai.api_key = self.api_keys["openai"]
            response = openai.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.7,
                max_tokens=2000
            )
            return response.choices[0].message.content
        except Exception as e:
            return f"OpenAI API hatası: {str(e)}"
    
    def generate_with_gemini(self, prompt: str, model: str = "gemini-1.5-pro") -> str:
        """
        Google Gemini API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            
        Returns:
            str: Oluşturulan yanıt
        """
        if not self.api_keys["gemini"]:
            return "Gemini API anahtarı ayarlanmamış."
        
        try:
            genai.configure(api_key=self.api_keys["gemini"])
            model_obj = genai.GenerativeModel(model)
            response = model_obj.generate_content(prompt)
            return response.text
        except Exception as e:
            return f"Gemini API hatası: {str(e)}"
    
    def generate_with_openrouter(self, prompt: str, model: str = "openai/gpt-4-turbo") -> str:
        """
        OpenRouter API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            
        Returns:
            str: Oluşturulan yanıt
        """
        if not self.api_keys["openrouter"]:
            return "OpenRouter API anahtarı ayarlanmamış."
        
        try:
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.api_keys['openrouter']}"
            }
            
            data = {
                "model": model,
                "messages": [{"role": "user", "content": prompt}],
                "temperature": 0.7,
                "max_tokens": 2000
            }
            
            response = requests.post(
                "https://openrouter.ai/api/v1/chat/completions",
                headers=headers,
                json=data
            )
            
            if response.status_code == 200:
                return response.json()["choices"][0]["message"]["content"]
            else:
                return f"OpenRouter API hatası: {response.status_code} - {response.text}"
        except Exception as e:
            return f"OpenRouter API hatası: {str(e)}"
    
    def generate_response(self, provider: str, prompt: str, model: Optional[str] = None) -> str:
        """
        Belirli bir sağlayıcı ve model kullanarak yanıt oluşturur.
        
        Args:
            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
            prompt (str): Gönderilecek prompt
            model (str, optional): Kullanılacak model
            
        Returns:
            str: Oluşturulan yanıt
        """
        if provider == "openai":
            if model is None:
                model = "gpt-3.5-turbo"
            return self.generate_with_openai(prompt, model)
        elif provider == "gemini":
            if model is None:
                model = "gemini-1.5-pro"
            return self.generate_with_gemini(prompt, model)
        elif provider == "openrouter":
            if model is None:
                model = "openai/gpt-4-turbo"
            return self.generate_with_openrouter(prompt, model)
        else:
            return "Geçersiz sağlayıcı. Lütfen 'openai', 'gemini' veya 'openrouter' seçin."


# Chatbot ve AI model arayüzü örneklerini oluştur
chatbot = PromptEngineerChatbot()
ai_interface = AIModelInterface()

# Test fonksiyonu
def test_chatbot():
    """
    Chatbot'u test eder.
    """
    test_input = "Bir e-ticaret web sitesi yapmak istiyorum. Ürünleri listeleyebilmeli, sepete ekleyebilmeli ve ödeme alabilmeliyim."
    prompt, category, params = chatbot.process_input(test_input, use_ai_generation=True)
    
    print(f"Kategori: {category}")
    print(f"Parametreler: {json.dumps(params, indent=2, ensure_ascii=False)}")
    print("\nOluşturulan Prompt:")
    print(prompt)
    
    # API yanıtı test (API anahtarı varsa)
    if ai_interface.api_keys["openai"]:
        print("\nOpenAI Yanıtı:")
        response = ai_interface.generate_response("openai", prompt)
        print(response)

if __name__ == "__main__":
    test_chatbot()