#نویسنده: ربات سخنگو هوشمند - نسخه API

from flask import Flask, request, jsonify, render_template_string
from flask_cors import CORS
import json
import os
import logging
import re
import random
from datetime import datetime
from typing import Dict, List, Optional, Any
from werkzeug.middleware.proxy_fix import ProxyFix

# -------------------- تنظیمات لاگ --------------------
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler('chatbot_api.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# -------------------- راه‌اندازی Flask --------------------
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
CORS(app)  # فعال کردن CORS برای همه درخواست‌ها

# -------------------- فایل‌های داده --------------------
POLITE_DATA_FILE = "Datatalker.json"
RUDE_DATA_FILE = "Data.json"
CONFIG_FILE = "chatbot_config.json"

# -------------------- شکلک‌ها --------------------
EMOJI = {
    "smile": "😊",
    "laugh": "😂",
    "angry": "😠",
    "heart": "❤️",
    "fire": "🔥",
    "star": "⭐",
    "check": "✅",
    "cross": "❌",
    "warning": "⚠️",
    "info": "ℹ️",
    "settings": "⚙️",
    "speech": "💬",
    "robot": "🤖",
    "crown": "👑"
}

# -------------------- کلاس مدیریت داده‌ها --------------------
class ChatbotDataManager:
    def __init__(self):
        self.polite_data: Dict[str, List[str]] = {}
        self.rude_data: Dict[str, List[str]] = {}
        self.current_mode = "polite"
        self.stats = {
            "total_requests": 0,
            "responses_given": 0,
            "mode_changes": 0,
            "uptime_start": datetime.now().isoformat()
        }
        self.load_all_data()
    
    def load_all_data(self):
        """بارگذاری تمام داده‌ها"""
        try:
            # بارگذاری دیتابیس با ادب
            if os.path.exists(POLITE_DATA_FILE):
                with open(POLITE_DATA_FILE, 'r', encoding='utf-8') as f:
                    self.polite_data = json.load(f)
                logger.info(f"دیتابیس با ادب بارگذاری شد: {len(self.polite_data)} کلید")
            else:
                logger.warning(f"فایل {POLITE_DATA_FILE} یافت نشد")
                self.polite_data = self.get_default_polite_data()
            
            # بارگذاری دیتابیس بی ادب
            if os.path.exists(RUDE_DATA_FILE):
                with open(RUDE_DATA_FILE, 'r', encoding='utf-8') as f:
                    self.rude_data = json.load(f)
                logger.info(f"دیتابیس بی ادب بارگذاری شد: {len(self.rude_data)} کلید")
            else:
                logger.warning(f"فایل {RUDE_DATA_FILE} یافت نشد")
                self.rude_data = self.get_default_rude_data()
            
            # بارگذاری تنظیمات
            if os.path.exists(CONFIG_FILE):
                with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.current_mode = config.get('current_mode', 'polite')
                    self.stats.update(config.get('stats', {}))
                logger.info(f"تنظیمات بارگذاری شد - مود: {self.current_mode}")
        except Exception as e:
            logger.error(f"خطا در بارگذاری: {e}")
    
    def save_config(self):
        """ذخیره تنظیمات"""
        try:
            config = {
                'current_mode': self.current_mode,
                'stats': self.stats
            }
            with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
                json.dump(config, f, ensure_ascii=False, indent=2)
        except Exception as e:
            logger.error(f"خطا در ذخیره: {e}")
    
    def get_default_polite_data(self) -> Dict[str, List[str]]:
        """داده‌های پیش‌فرض با ادب"""
        return {
            "سلام": ["سلام! چطور می‌توانم به شما کمک کنم؟ 😊", "درود! روز خوبی داشته باشید 🌹"],
            "چطوری": ["خوبم، ممنون! شما چطورید؟ 😊", "عالی‌ام! خدا رو شکر ✨"],
            "خداحافظ": ["خدانگهدار! موفق باشید 🌹", "به امید دیدار مجدد! 👋"],
            "ممنون": ["خواهش می‌کنم! 🌹", "خوشحالم که تونستم کمک کنم 😊"],
            "خوبی": ["بله، ممنون! شما چطورید؟ 😊", "عالی‌ام! خدا رو شکر ✨"],
            "default": ["ممنون از پیامتان! 😊", "چه جالب! 🌹"]
        }
    
    def get_default_rude_data(self) -> Dict[str, List[str]]:
        """داده‌های پیش‌فرض بی ادب"""
        return {
            "سلام": ["خوبی؟ بگو ببینم", "چیه باز سلام کردی؟", "سلااام، بگو چیکارت کنم"],
            "چطوری": ["خودم خوبم تو خوب باشی", "فدات... بگذریم", "خوبم ولی تو رو چه"],
            "خداحافظ": ["بای بای، برو پی کارت", "خدافظ... نمیخوام برگردی", "برو گمشو"],
            "ممنون": ["باشه بسه", "خودتو ناراحت نکن", "قابل نداره"],
            "خوبی": ["خودم خوبم تو بیا بگو", "تو خوبی من خوبم", "بخوبی خودت"],
            "default": ["چی میگی؟ 🤦", "بسه دیگه", "بچ سالا فازت چیه"]
        }
    
    def get_current_data(self) -> Dict[str, List[str]]:
        """دریافت دیتابیس بر اساس مود فعلی"""
        return self.rude_data if self.current_mode == "rude" else self.polite_data
    
    def find_best_response(self, user_message: str) -> Optional[str]:
        """پیدا کردن بهترین پاسخ برای پیام کاربر"""
        msg_lower = user_message.lower().strip()
        data = self.get_current_data()
        
        # حذف علائم و فاصله‌های اضافی
        msg_clean = re.sub(r'[^\w\s]', '', msg_lower)
        
        best_match = None
        best_score = 0
        
        # جستجو در کلیدهای دیتابیس
        for key, responses in data.items():
            if key == "default":
                continue
            
            key_lower = key.lower()
            
            # تطابق کامل
            if msg_lower == key_lower or msg_clean == key_lower:
                self.stats["responses_given"] += 1
                self.save_config()
                return random.choice(responses)
            
            # تطابق جزیی
            if key_lower in msg_lower or msg_lower in key_lower:
                score = len(key_lower) / len(msg_lower) if len(msg_lower) > 0 else 0
                if score > best_score:
                    best_score = score
                    best_match = responses
        
        if best_match and best_score > 0.4:
            self.stats["responses_given"] += 1
            self.save_config()
            return random.choice(best_match)
        
        # پاسخ پیش‌فرض
        default_responses = data.get("default", [])
        if default_responses:
            self.stats["responses_given"] += 1
            self.save_config()
            return random.choice(default_responses)
        
        return None
    
    def change_mode(self, mode: str) -> Dict[str, Any]:
        """تغییر مود ربات"""
        if mode not in ["polite", "rude"]:
            return {"success": False, "message": "مود نامعتبر! مقادیر معتبر: polite, rude"}
        
        old_mode = self.current_mode
        self.current_mode = mode
        self.stats["mode_changes"] += 1
        self.save_config()
        
        return {
            "success": True,
            "old_mode": old_mode,
            "new_mode": self.current_mode,
            "message": f"مود از {old_mode} به {self.current_mode} تغییر کرد"
        }
    
    def get_status(self) -> Dict[str, Any]:
        """دریافت وضعیت فعلی"""
        return {
            "success": True,
            "mode": self.current_mode,
            "mode_name": "بی ادب" if self.current_mode == "rude" else "با ادب",
            "polite_keys": len(self.polite_data),
            "rude_keys": len(self.rude_data),
            "stats": self.stats
        }

# -------------------- ایجاد نمونه از کلاس مدیریت --------------------
chatbot = ChatbotDataManager()

# ==================== صفحه HTML ساده ====================
HTML_TEMPLATE = '''
<!DOCTYPE html>
<html dir="rtl" lang="fa">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ربات سخنگو - API سرویس</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        body {
            font-family: 'Vazir', 'Tahoma', sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            padding: 20px;
        }
        .container {
            max-width: 800px;
            margin: 0 auto;
        }
        .card {
            background: rgba(255, 255, 255, 0.95);
            border-radius: 20px;
            padding: 30px;
            margin-bottom: 20px;
            box-shadow: 0 10px 40px rgba(0,0,0,0.2);
        }
        h1 {
            color: #667eea;
            text-align: center;
            margin-bottom: 10px;
        }
        .subtitle {
            text-align: center;
            color: #666;
            margin-bottom: 30px;
        }
        .api-url {
            background: #f0f0f0;
            padding: 15px;
            border-radius: 10px;
            font-family: monospace;
            direction: ltr;
            text-align: left;
            margin: 20px 0;
            overflow-x: auto;
        }
        .input-group {
            display: flex;
            gap: 10px;
            margin: 20px 0;
        }
        input {
            flex: 1;
            padding: 12px;
            border: 2px solid #ddd;
            border-radius: 10px;
            font-size: 16px;
            font-family: inherit;
        }
        button {
            padding: 12px 24px;
            background: #667eea;
            color: white;
            border: none;
            border-radius: 10px;
            cursor: pointer;
            font-size: 16px;
            transition: all 0.3s;
        }
        button:hover {
            background: #5a67d8;
            transform: translateY(-2px);
        }
        .response-box {
            background: #f8f9fa;
            padding: 20px;
            border-radius: 10px;
            margin-top: 20px;
            border-right: 4px solid #667eea;
        }
        .mode-buttons {
            display: flex;
            gap: 10px;
            margin: 20px 0;
        }
        .mode-btn {
            flex: 1;
            background: #e0e0e0;
            color: #333;
        }
        .mode-btn.active {
            background: #667eea;
            color: white;
        }
        .status {
            background: #e8f5e9;
            padding: 15px;
            border-radius: 10px;
            margin: 20px 0;
        }
        .footer {
            text-align: center;
            color: rgba(255,255,255,0.8);
            margin-top: 20px;
        }
        code {
            background: #e0e0e0;
            padding: 2px 6px;
            border-radius: 5px;
            font-family: monospace;
        }
        @media (max-width: 600px) {
            .input-group {
                flex-direction: column;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="card">
            <h1>🤖 ربات سخنگو هوشمند</h1>
            <div class="subtitle">سرویس API برای پاسخگویی خودکار</div>
            
            <div class="api-url">
                <strong>📡 آدرس API:</strong><br>
                <code>https://hakhamanesh-bot.ir/api/vassiss/?text={متن شما}</code>
            </div>
            
            <div class="mode-buttons">
                <button class="mode-btn" id="politeBtn" onclick="changeMode('polite')">
                    😊 مود با ادب
                </button>
                <button class="mode-btn" id="rudeBtn" onclick="changeMode('rude')">
                    😠 مود بی ادب
                </button>
            </div>
            
            <div class="status" id="status">
                وضعیت: در حال بارگذاری...
            </div>
            
            <div class="input-group">
                <input type="text" id="messageInput" placeholder="متن خود را وارد کنید..." onkeypress="if(event.key==='Enter') sendMessage()">
                <button onclick="sendMessage()">ارسال</button>
            </div>
            
            <div class="response-box" id="responseBox">
                <strong>💬 پاسخ ربات:</strong><br>
                <span id="responseText">منتظر پیام شما هستم...</span>
            </div>
        </div>
        
        <div class="footer">
            🔧 برای استفاده در پروژه‌های خود از API استفاده کنید
        </div>
    </div>
    
    <script>
        let currentMode = '{{ mode }}';
        
        async function changeMode(mode) {
            try {
                const response = await fetch(`/api/mode?mode=${mode}`);
                const data = await response.json();
                if (data.success) {
                    currentMode = mode;
                    updateModeButtons();
                    loadStatus();
                    showToast(`مود به ${mode === 'polite' ? 'با ادب' : 'بی ادب'} تغییر کرد`, 'success');
                }
            } catch (error) {
                console.error('Error:', error);
                showToast('خطا در تغییر مود', 'error');
            }
        }
        
        async function sendMessage() {
            const input = document.getElementById('messageInput');
            const text = input.value.trim();
            
            if (!text) {
                showToast('لطفاً متنی وارد کنید', 'warning');
                return;
            }
            
            const responseText = document.getElementById('responseText');
            responseText.innerHTML = '<span style="color: #999;">در حال پردازش...</span>';
            
            try {
                const response = await fetch(`/api/vassiss/?text=${encodeURIComponent(text)}`);
                const data = await response.json();
                
                if (data.success) {
                    responseText.innerHTML = data.response;
                } else {
                    responseText.innerHTML = 'خطا: ' + (data.message || 'مشکلی پیش آمده');
                }
            } catch (error) {
                console.error('Error:', error);
                responseText.innerHTML = 'خطا در ارتباط با سرور';
            }
            
            input.value = '';
        }
        
        async function loadStatus() {
            try {
                const response = await fetch('/api/status');
                const data = await response.json();
                if (data.success) {
                    const statusDiv = document.getElementById('status');
                    statusDiv.innerHTML = `
                        <strong>📊 وضعیت ربات:</strong><br>
                        🎭 مود فعلی: <strong>${data.mode_name}</strong><br>
                        📚 کلیدهای با ادب: ${data.polite_keys}<br>
                        📚 کلیدهای بی ادب: ${data.rude_keys}<br>
                        📈 کل درخواست‌ها: ${data.stats.total_requests}<br>
                        💬 پاسخ‌های داده شده: ${data.stats.responses_given}
                    `;
                    updateModeButtons();
                }
            } catch (error) {
                console.error('Error:', error);
            }
        }
        
        function updateModeButtons() {
            const politeBtn = document.getElementById('politeBtn');
            const rudeBtn = document.getElementById('rudeBtn');
            
            if (currentMode === 'polite') {
                politeBtn.classList.add('active');
                rudeBtn.classList.remove('active');
            } else {
                politeBtn.classList.remove('active');
                rudeBtn.classList.add('active');
            }
        }
        
        function showToast(message, type) {
            const toast = document.createElement('div');
            toast.textContent = message;
            toast.style.cssText = `
                position: fixed;
                bottom: 20px;
                right: 20px;
                background: ${type === 'success' ? '#4caf50' : type === 'error' ? '#f44336' : '#ff9800'};
                color: white;
                padding: 12px 24px;
                border-radius: 8px;
                z-index: 1000;
                animation: fadeInOut 3s ease;
            `;
            document.body.appendChild(toast);
            setTimeout(() => toast.remove(), 3000);
        }
        
        // اضافه کردن انیمیشن
        const style = document.createElement('style');
        style.textContent = `
            @keyframes fadeInOut {
                0% { opacity: 0; transform: translateY(20px); }
                15% { opacity: 1; transform: translateY(0); }
                85% { opacity: 1; transform: translateY(0); }
                100% { opacity: 0; transform: translateY(20px); }
            }
        `;
        document.head.appendChild(style);
        
        // بارگذاری اولیه
        loadStatus();
    </script>
</body>
</html>
'''

# ==================== API ENDPOINTS ====================

@app.route('/')
def index():
    """صفحه اصلی"""
    return render_template_string(HTML_TEMPLATE, mode=chatbot.current_mode)


@app.route('/api/vassiss/')
def api_chat():
    """API اصلی برای دریافت پاسخ"""
    chatbot.stats["total_requests"] += 1
    chatbot.save_config()
    
    # دریافت متن از پارامترها
    text = request.args.get('text', '')
    if not text:
        return jsonify({
            "success": False,
            "error": "Missing 'text' parameter",
            "message": "لطفاً پارامتر text را ارسال کنید",
            "example": "/api/vassiss/?text=سلام"
        }), 400
    
    # دریافت پاسخ
    response = chatbot.find_best_response(text)
    
    if response:
        return jsonify({
            "success": True,
            "input": text,
            "response": response,
            "mode": chatbot.current_mode,
            "timestamp": datetime.now().isoformat()
        })
    else:
        return jsonify({
            "success": False,
            "input": text,
            "message": "پاسخی یافت نشد",
            "mode": chatbot.current_mode,
            "timestamp": datetime.now().isoformat()
        }), 404


@app.route('/api/mode', methods=['GET', 'POST'])
def change_mode():
    """تغییر مود ربات"""
    if request.method == 'GET':
        mode = request.args.get('mode', '')
    else:
        data = request.get_json() or {}
        mode = data.get('mode', '')
    
    if not mode:
        return jsonify({
            "success": False,
            "message": "لطفاً پارامتر mode را ارسال کنید (polite یا rude)"
        }), 400
    
    result = chatbot.change_mode(mode)
    return jsonify(result)


@app.route('/api/status')
def get_status():
    """دریافت وضعیت ربات"""
    return jsonify(chatbot.get_status())


@app.route('/api/stats')
def get_stats():
    """دریافت آمار کامل"""
    return jsonify({
        "success": True,
        "stats": chatbot.stats,
        "current_mode": chatbot.current_mode,
        "polite_data_size": len(chatbot.polite_data),
        "rude_data_size": len(chatbot.rude_data)
    })


@app.route('/api/reload', methods=['POST'])
def reload_data():
    """بارگذاری مجدد داده‌ها (برای مدیریت)"""
    try:
        chatbot.load_all_data()
        return jsonify({
            "success": True,
            "message": "داده‌ها با موفقیت بارگذاری مجدد شدند",
            "polite_keys": len(chatbot.polite_data),
            "rude_keys": len(chatbot.rude_data)
        })
    except Exception as e:
        return jsonify({
            "success": False,
            "message": f"خطا در بارگذاری: {str(e)}"
        }), 500


@app.route('/api/health')
def health_check():
    """بررسی سلامت سرویس"""
    return jsonify({
        "status": "healthy",
        "uptime": chatbot.stats.get("uptime_start"),
        "mode": chatbot.current_mode
    })


# -------------------- هندلر خطاها --------------------
@app.errorhandler(404)
def not_found(error):
    return jsonify({
        "success": False,
        "error": "Endpoint not found",
        "available_endpoints": [
            "/",
            "/api/vassiss/?text={message}",
            "/api/mode?mode=polite|rude",
            "/api/status",
            "/api/stats",
            "/api/reload",
            "/api/health"
        ]
    }), 404


@app.errorhandler(500)
def internal_error(error):
    return jsonify({
        "success": False,
        "error": "Internal server error",
        "message": "مشکلی در سرور رخ داده است"
    }), 500


# -------------------- اجرای اصلی --------------------
if __name__ == "__main__":
    import sys
    
    # پورت پیش‌فرض برای اجرا در هاست
    port = int(os.environ.get('PORT', 5000))
    debug = os.environ.get('DEBUG', 'False').lower() == 'true'
    
    logger.info("=" * 50)
    logger.info("ربات سخنگو - سرویس API راه‌اندازی شد")
    logger.info(f"مود فعلی: {chatbot.current_mode}")
    logger.info(f"دیتابیس با ادب: {len(chatbot.polite_data)} کلید")
    logger.info(f"دیتابیس بی ادب: {len(chatbot.rude_data)} کلید")
    logger.info("=" * 50)
    
    # اجرای اپلیکیشن
    app.run(host='0.0.0.0', port=port, debug=debug)