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
import re
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, load_env_safely

# .env dosyasını güvenli şekilde yükle
# Not: ai_prompt_generator modülünde zaten yükleniyor, burada tekrar çağırmaya gerek yok
# load_env_safely()

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:
            try:
                # Şablon tabanlı promptu oluştur (referans için)
                template_prompt = create_prompt(category, params)
                
                # Kullanıcının belirttiği özel teknolojilere vurgu yapalım
                user_input_lower = user_input.lower()
                special_tech_notes = ""
                
                if "bootstrap" in user_input_lower:
                    special_tech_notes += "\n- Bootstrap framework'ü kullanılmalıdır."
                if "react" in user_input_lower:
                    special_tech_notes += "\n- React kütüphanesi kullanılmalıdır."
                if "vue" in user_input_lower:
                    special_tech_notes += "\n- Vue.js framework'ü kullanılmalıdır."
                if "angular" in user_input_lower:
                    special_tech_notes += "\n- Angular framework'ü kullanılmalıdır."
                if "tailwind" in user_input_lower:
                    special_tech_notes += "\n- Tailwind CSS kullanılmalıdır."
                
                # Özel teknoloji notları varsa ekleyelim
                tech_emphasis = ""
                if special_tech_notes:
                    tech_emphasis = f"\n\nÖNEMLİ TEKNOLOJİ GEREKSİNİMLERİ: {special_tech_notes}"
                
                # 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}{tech_emphasis}
                
                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.
                """
                
                # API anahtarı kontrolü
                if not self.ai_generator.openai_api_key and provider == "openai":
                    prompt = template_prompt
                elif not self.ai_generator.gemini_api_key and provider == "gemini":
                    prompt = template_prompt
                elif not self.ai_generator.openrouter_api_key and provider == "openrouter":
                    prompt = template_prompt
                else:
                    # AI destekli prompt oluştur
                    result = self.ai_generator.generate_prompt(enhanced_user_input, provider, model)
                    
                    if result["success"]:
                        prompt = result["prompt"]
                    else:
                        # Hata mesajını logla ve şablon promptu kullan
                        print(f"AI prompt oluşturma hatası: {result.get('error', 'Bilinmeyen hata')}")
                        prompt = template_prompt
            except Exception as e:
                print(f"Prompt oluşturma hatası: {str(e)}")
                # Hata durumunda şablon promptu kullan
                prompt = create_prompt(category, params)
        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", api_key: Optional[str] = None) -> str:
        """
        OpenAI API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            api_key (str, optional): Doğrudan kullanılacak API anahtarı
            
        Returns:
            str: Oluşturulan yanıt
        """
        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
        current_api_key = api_key if api_key else self.api_keys["openai"]
        
        if not current_api_key:
            return "OpenAI API anahtarı ayarlanmamış."
        
        try:
            # Geçici olarak API anahtarını ayarla
            openai.api_key = current_api_key
            
            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", api_key: Optional[str] = None) -> str:
        """
        Google Gemini API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            api_key (str, optional): Doğrudan kullanılacak API anahtarı
            
        Returns:
            str: Oluşturulan yanıt
        """
        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
        current_api_key = api_key if api_key else self.api_keys["gemini"]
        
        if not current_api_key:
            return "Gemini API anahtarı ayarlanmamış."
        
        try:
            # Geçici olarak API anahtarını ayarla
            genai.configure(api_key=current_api_key)
            
            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", api_key: Optional[str] = None) -> str:
        """
        OpenRouter API kullanarak yanıt oluşturur.
        
        Args:
            prompt (str): Gönderilecek prompt
            model (str): Kullanılacak model
            api_key (str, optional): Doğrudan kullanılacak API anahtarı
            
        Returns:
            str: Oluşturulan yanıt
        """
        # Doğrudan API anahtarı verilmişse onu kullan, yoksa saklanan anahtarı kullan
        current_api_key = api_key if api_key else self.api_keys["openrouter"]
        
        if not current_api_key:
            return "OpenRouter API anahtarı ayarlanmamış."
        
        try:
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {current_api_key}"
            }
            
            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_code_templates(self, response: str) -> Dict[str, Any]:
        """
        AI yanıtından kod şablonları, dizin yapısı ve uygulama adımlarını çıkarır.
        
        Args:
            response (str): AI yanıtı
            
        Returns:
            Dict[str, Any]: Kod şablonları, dizin yapısı ve uygulama adımları
        """
        result = {
            "directory_structure": [],
            "code_templates": [],
            "implementation_steps": []
        }
        
        # Dizin yapısını çıkar
        dir_structure_pattern = r"```(?:bash|shell|plaintext)?\s*((?:├──|└──|│\s+|(?:\w+/)+\w+|\w+\.\w+|[\w\-\.\/]+\s*)+)\s*```"
        dir_matches = re.findall(dir_structure_pattern, response, re.DOTALL)
        
        if dir_matches:
            for match in dir_matches:
                if any(x in match for x in ['├──', '└──', '│', '/']):
                    result["directory_structure"].append(match.strip())
        
        # Kod şablonlarını çıkar
        code_pattern = r"```(\w+)?\s*([\s\S]*?)```"
        code_matches = re.findall(code_pattern, response, re.DOTALL)
        
        for lang, code in code_matches:
            if lang and lang.lower() not in ['bash', 'shell', 'plaintext', '']:
                result["code_templates"].append({
                    "language": lang.strip() if lang else "unknown",
                    "code": code.strip()
                })
        
        # Uygulama adımlarını çıkar
        steps_pattern = r"(?:##|###)\s*(?:Adım|Step|İmplementasyon|Uygulama).*?(?=(?:##|###)|$)"
        steps_matches = re.findall(steps_pattern, response, re.DOTALL | re.IGNORECASE)
        
        if steps_matches:
            result["implementation_steps"] = [step.strip() for step in steps_matches]
        else:
            # Numaralı adımları ara
            numbered_steps = re.findall(r"\d+\.\s+[^\n]+(?:\n(?!\d+\.).*?)*", response, re.DOTALL)
            if numbered_steps:
                result["implementation_steps"] = [step.strip() for step in numbered_steps]
        
        return result
    
    def generate_response_with_code_templates(self, provider: str, prompt: str, model: Optional[str] = None, api_key: Optional[str] = None) -> Dict[str, Any]:
        """
        Belirli bir sağlayıcı ve model kullanarak yanıt ve kod şablonları oluşturur.
        
        Args:
            provider (str): API sağlayıcısı ('openai', 'gemini', 'openrouter')
            prompt (str): Gönderilecek prompt
            model (str, optional): Kullanılacak model
            api_key (str, optional): Doğrudan kullanılacak API anahtarı
            
        Returns:
            Dict[str, Any]: Yanıt ve kod şablonları
        """
        # Promptu geliştir - kod şablonları, dizin yapısı ve uygulama adımları isteyelim
        enhanced_prompt = f"""
        {prompt}
        
        Lütfen yanıtında aşağıdakileri mutlaka içer:
        
        1. Detaylı bir dizin yapısı (klasör ve dosya hiyerarşisi)
        2. Önemli dosyaların kod şablonları (HTML, CSS, JavaScript, Python vb.)
        3. Adım adım uygulama talimatları
        
        Dizin yapısını ```bash veya ```plaintext içinde göster.
        Kod şablonlarını ```html, ```css, ```javascript, ```python gibi uygun dil belirteçleriyle göster.
        Uygulama adımlarını numaralandırılmış liste olarak veya ## Adım başlıkları altında göster.
        """
        
        # Yanıt oluştur
        response = self.generate_response(provider, enhanced_prompt, model, api_key)
        
        # Yanıttan kod şablonlarını çıkar
        templates = self.generate_code_templates(response)
        
        return {
            "response": response,
            "templates": templates
        }
    
    def generate_response(self, provider: str, prompt: str, model: Optional[str] = None, api_key: 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
            api_key (str, optional): Doğrudan kullanılacak API anahtarı
            
        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, api_key)
        elif provider == "gemini":
            if model is None:
                model = "gemini-1.5-pro"
            return self.generate_with_gemini(prompt, model, api_key)
        elif provider == "openrouter":
            if model is None:
                model = "openai/gpt-4-turbo"
            return self.generate_with_openrouter(prompt, model, api_key)
        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()