"""
🤖 ChatGPT Sender Module
ماژول مستقل برای ارسال متن ناشناس‌شده به ChatGPT
استفاده برای: برنامه‌های مختلف، API‌ها، و سیستم‌های تحلیل
"""

import requests
import os
import logging
from typing import Dict, Optional, Tuple
import time

# تنظیم logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class ChatGPTSender:
    """
    کلاس برای ارسال متن به ChatGPT با قابلیت‌های پیشرفته
    """
    
    def __init__(self, api_key: Optional[str] = None, model: str = "gpt-4o-mini"):
        """
        اولیه‌سازی
        
        Args:
            api_key: کلید OpenAI API (اگر None، از متغیر محیطی خوانده می‌شود)
            model: مدل مورد استفاده (پیش‌فرض: gpt-4o-mini)
        """
        self.api_key = api_key or os.getenv("OPENAI_API_KEY", "")
        self.model = model
        self.base_url = "https://api.openai.com/v1/chat/completions"
        
        if not self.api_key:
            logger.warning("⚠️  کلید API تنظیم نشده است!")
    
    def set_api_key(self, api_key: str):
        """تنظیم کلید API"""
        self.api_key = api_key
        logger.info("✅ کلید API تنظیم شد")
    
    def set_model(self, model: str):
        """تغییر مدل ChatGPT"""
        self.model = model
        logger.info(f"✅ مدل تغییر یافت به: {model}")
    
    def send_simple(self, text: str, lang: str = 'fa') -> str:
        """
        ارسال ساده (بدون system message سفارشی)
        
        Args:
            text: متن ارسالی
            lang: زبان ('fa' یا 'en')
        
        Returns:
            پاسخ از ChatGPT
        """
        system_msg = (
            "شما یک تحلیلگر متخصص هستید. متن حاوی کدهای ناشناس است. "
            "به درخواست‌ها با دقت و حرفه‌ای‌ی پاسخ دهید."
            if lang == 'fa' 
            else "You are a professional analyst. The text contains anonymous codes. "
                 "Answer requests accurately and professionally."
        )
        
        return self.send(text, system_msg=system_msg, lang=lang)
    
    def send(
        self,
        text: str,
        system_msg: Optional[str] = None,
        max_tokens: int = 2000,
        temperature: float = 0.7,
        timeout: int = 60,
        lang: str = 'fa',
        retry_count: int = 3
    ) -> str:
        """
        ارسال متن به ChatGPT با کنترل کامل
        
        Args:
            text: متن ارسالی
            system_msg: پیام سیستم سفارشی
            max_tokens: حداکثر توکن پاسخ
            temperature: میزان خلاقیت (0-2)
            timeout: زمان انتظار (ثانیه)
            lang: زبان ('fa' یا 'en')
            retry_count: تعداد تلاش مجدد
        
        Returns:
            پاسخ از ChatGPT
        """
        try:
            # بررسی اولیه
            if not text or not text.strip():
                error_msg = "متن خالی است!" if lang == 'fa' else "Text is empty!"
                logger.error(f"❌ {error_msg}")
                return f"❌ {error_msg}"
            
            if not self.api_key:
                error_msg = "کلید API تنظیم نشده است!" if lang == 'fa' else "API Key not configured!"
                logger.error(f"❌ {error_msg}")
                return f"❌ {error_msg}"
            
            # تنظیم system message پیش‌فرض
            if system_msg is None:
                system_msg = (
                    "شما یک تحلیلگر مالی حرفه‌ای هستید. متن حاوی کدهای ناشناس است. "
                    "به سوالات با دقت پاسخ دهید."
                    if lang == 'fa'
                    else "You are a professional financial analyst. The text contains anonymous codes. "
                         "Answer questions accurately."
                )
            
            # تهیه headers
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            
            # ساخت request body
            data = {
                "model": self.model,
                "messages": [
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": text}
                ],
                "max_tokens": max_tokens,
                "temperature": temperature
            }
            
            # ارسال با retry mechanism
            for attempt in range(retry_count):
                try:
                    logger.info(f"📤 ارسال درخواست (تلاش {attempt + 1}/{retry_count})...")
                    
                    response = requests.post(
                        self.base_url,
                        headers=headers,
                        json=data,
                        timeout=timeout
                    )
                    
                    # پردازش پاسخ موفق
                    if response.status_code == 200:
                        result = response.json()
                        gpt_response = result['choices'][0]['message']['content']
                        logger.info("✅ پاسخ دریافت شد")
                        return gpt_response
                    
                    # پردازش خطاهای مختلف
                    elif response.status_code == 429:  # Rate limiting
                        wait_time = 5 * (attempt + 1)
                        logger.warning(
                            f"⚠️  Rate limit | جانب: {wait_time} ثانیه صبر کن"
                        )
                        if attempt < retry_count - 1:
                            time.sleep(wait_time)
                            continue
                        else:
                            return (
                                "❌ سهمیه API تمام شده است. لطفاً بعداً تلاش کنید."
                                if lang == 'fa'
                                else "❌ API quota exceeded. Please try later."
                            )
                    
                    elif response.status_code == 401:
                        return (
                            "❌ کلید API نامعتبر است!"
                            if lang == 'fa'
                            else "❌ Invalid API key!"
                        )
                    
                    elif response.status_code in [502, 503, 504]:  # Server errors
                        wait_time = 2 * (attempt + 1)
                        logger.warning(
                            f"⚠️  Server error {response.status_code} | "
                            f"صبر: {wait_time} ثانیه"
                        )
                        if attempt < retry_count - 1:
                            time.sleep(wait_time)
                            continue
                        else:
                            return (
                                f"❌ خطای سرور: {response.status_code}"
                                if lang == 'fa'
                                else f"❌ Server error: {response.status_code}"
                            )
                    
                    else:
                        # خطای دیگر
                        error_data = response.json() if response.content else {}
                        error_msg = error_data.get('error', {}).get('message', response.text)
                        logger.error(f"❌ API Error: {error_msg}")
                        return f"❌ API Error: {error_msg}"
                
                except requests.exceptions.Timeout:
                    logger.warning(
                        f"⚠️  Timeout | صبر: 3 ثانیه و تلاش مجدد"
                    )
                    if attempt < retry_count - 1:
                        time.sleep(3)
                        continue
                    else:
                        return (
                            "❌ خطای اتصال: timeout"
                            if lang == 'fa'
                            else "❌ Connection error: timeout"
                        )
                
                except requests.exceptions.ConnectionError as e:
                    logger.warning(
                        f"⚠️  Connection error | صبر: 2 ثانیه و تلاش مجدد"
                    )
                    if attempt < retry_count - 1:
                        time.sleep(2)
                        continue
                    else:
                        return (
                            f"❌ خطای اتصال: {str(e)}"
                            if lang == 'fa'
                            else f"❌ Connection error: {str(e)}"
                        )
        
        except Exception as e:
            logger.error(f"❌ خطای غیرمنتظره: {str(e)}")
            return (
                f"❌ خطا در ارتباط با ChatGPT: {str(e)}"
                if lang == 'fa'
                else f"❌ Error connecting to ChatGPT: {str(e)}"
            )
    
    def batch_send(
        self,
        texts: list,
        delay: float = 1.0,
        **kwargs
    ) -> Dict[str, str]:
        """
        ارسال چندین متن با تاخیر بین‌شان
        
        Args:
            texts: لیست متن‌های ارسالی
            delay: تاخیر بین درخواست‌ها (ثانیه)
            **kwargs: سایر پارامترهای send()
        
        Returns:
            دیکشنری {متن: پاسخ}
        """
        results = {}
        
        for i, text in enumerate(texts, 1):
            logger.info(f"📤 درخواست {i}/{len(texts)}")
            response = self.send(text, **kwargs)
            results[text[:50] + "..."] = response
            
            if i < len(texts):
                logger.info(f"⏳ صبر {delay} ثانیه...")
                time.sleep(delay)
        
        return results


# تابع standalone برای استفاده سریع
def send_to_chatgpt_simple(
    text: str,
    api_key: Optional[str] = None,
    model: str = "gpt-4o-mini",
    lang: str = 'fa'
) -> str:
    """
    تابع سریع برای ارسال متن به ChatGPT
    
    مثال:
        response = send_to_chatgpt_simple("سلام، چطور می‌تونم خبر خوب داشته باشم؟")
    """
    sender = ChatGPTSender(api_key=api_key, model=model)
    return sender.send_simple(text, lang=lang)


if __name__ == "__main__":
    # مثال استفاده
    print("=" * 60)
    print("🤖 ChatGPT Sender Module - مثال استفاده")
    print("=" * 60)
    
    # روش 1: استفاده سریع
    print("\n1️⃣  استفاده سریع:")
    # result = send_to_chatgpt_simple("سلام")
    
    # روش 2: استفاده از کلاس
    print("\n2️⃣  استفاده از کلاس:")
    sender = ChatGPTSender()
    
    if sender.api_key:
        response = sender.send_simple("تست سیستم")
        print(f"✅ پاسخ: {response[:100]}...")
    else:
        print("⚠️  کلید API تنظیم نشده است!")
        print("   راهنمایی: export OPENAI_API_KEY='your-key-here'")