#!/usr/bin/env python3
"""
Multi-language Chatbot Application
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
Description: Advanced multi-language chatbot with automatic translation and cultural adaptation
"""

from flask import Flask, render_template, request, jsonify, session
from flask_cors import CORS
import openai
import googletrans
from langdetect import detect
import json
import os
import tempfile
import base64
from datetime import datetime
import logging

from modules.language_detector import LanguageDetector
from modules.translator import Translator
from modules.cultural_adapter import CulturalAdapter
from modules.chatbot_core import ChatbotCore
from modules.voice_processor import VoiceProcessor
from modules.sentiment_analyzer import SentimentAnalyzer
from modules.conversation_memory import ConversationMemory
from modules.document_analyzer import DocumentAnalyzer
from modules.collaboration_manager import CollaborationManager
from modules.analytics_engine import AnalyticsEngine
from modules.personality_engine import PersonalityEngine
from modules.multimodal_processor import MultiModalProcessor

app = Flask(__name__)
app.secret_key = 'multi-language-chatbot-rsk-world-2026'
CORS(app)

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MultiLanguageChatbot:
    def __init__(self):
        self.language_detector = LanguageDetector()
        self.translator = Translator()
        self.cultural_adapter = CulturalAdapter()
        self.chatbot_core = ChatbotCore()
        
        # Advanced features
        self.voice_processor = VoiceProcessor()
        self.sentiment_analyzer = SentimentAnalyzer()
        self.conversation_memory = ConversationMemory()
        self.document_analyzer = DocumentAnalyzer()
        self.collaboration_manager = CollaborationManager()
        self.analytics_engine = AnalyticsEngine()
        self.personality_engine = PersonalityEngine()
        self.multimodal_processor = MultiModalProcessor()
        
        # Supported languages
        self.supported_languages = {
            'en': 'English',
            'hi': 'हिन्दी (Hindi)',
            'bn': 'বাংলা (Bengali)',
            'es': 'Español (Spanish)',
            'fr': 'Français (French)',
            'de': 'Deutsch (German)',
            'zh': '中文 (Chinese)',
            'ja': '日本語 (Japanese)',
            'ar': 'العربية (Arabic)',
            'pt': 'Português (Portuguese)',
            'ru': 'Русский (Russian)',
            'it': 'Italiano (Italian)'
        }
        
    def process_message(self, message, user_language=None):
        """Process incoming message and generate response"""
        try:
            # Detect language if not provided
            if not user_language:
                detected_lang = self.language_detector.detect(message)
                user_language = detected_lang if detected_lang in self.supported_languages else 'en'
            else:
                # If user_language is provided, still detect for analytics
                detected_lang = self.language_detector.detect(message)
                if detected_lang not in self.supported_languages:
                    detected_lang = user_language
            
            # Store user language in session
            session['user_language'] = user_language
            
            # Translate to English for processing if needed
            if user_language != 'en':
                message_en = self.translator.translate(message, 'en', user_language)
            else:
                message_en = message
            
            # Generate response in English
            response_en = self.chatbot_core.generate_response(message_en)
            
            # Apply cultural adaptation
            response_en = self.cultural_adapter.adapt(response_en, user_language)
            
            # Translate response back to user language
            if user_language != 'en':
                response = self.translator.translate(response_en, user_language, 'en')
            else:
                response = response_en
            
            # Track analytics
            self.analytics_engine.track_user_event(
                user_id='default',
                event_type='message',
                event_data={'message_length': len(message)},
                language=detected_lang
            )
            
            # Store in conversation memory
            self.conversation_memory.add_message(
                user_id='default',
                role='user',
                content=message,
                language=detected_lang,
                sentiment=None
            )
            
            return {
                'response': response,
                'detected_language': user_language,
                'language_name': self.supported_languages.get(user_language, 'English'),
                'confidence': self.language_detector.get_confidence()
            }
            
        except Exception as e:
            logger.error(f"Error processing message: {str(e)}")
            return {
                'response': f"Sorry, I encountered an error. Please try again. (Error: {str(e)})",
                'detected_language': 'en',
                'language_name': 'English',
                'confidence': 0.0
            }

chatbot = MultiLanguageChatbot()

@app.route('/')
def index():
    """Main chat interface"""
    return render_template('index.html', 
                         supported_languages=chatbot.supported_languages,
                         current_year=datetime.now().year)

@app.route('/chat', methods=['POST'])
def chat():
    """Handle chat messages"""
    try:
        data = request.get_json()
        message = data.get('message', '').strip()
        user_language = data.get('language', None)
        
        if not message:
            return jsonify({'error': 'Message cannot be empty'}), 400
        
        response = chatbot.process_message(message, user_language)
        return jsonify(response)
        
    except Exception as e:
        logger.error(f"Chat endpoint error: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/detect_language', methods=['POST'])
def detect_language():
    """Detect language of given text"""
    try:
        data = request.get_json()
        text = data.get('text', '').strip()
        
        if not text:
            return jsonify({'error': 'Text cannot be empty'}), 400
        
        detected_lang = chatbot.language_detector.detect(text)
        confidence = chatbot.language_detector.get_confidence()
        
        return jsonify({
            'language': detected_lang,
            'language_name': chatbot.supported_languages.get(detected_lang, 'Unknown'),
            'confidence': confidence
        })
        
    except Exception as e:
        logger.error(f"Language detection error: {str(e)}")
        return jsonify({'error': 'Language detection failed'}), 500

@app.route('/translate', methods=['POST'])
def translate_text():
    """Translate text between languages"""
    try:
        data = request.get_json()
        text = data.get('text', '').strip()
        target_lang = data.get('target_language', 'en')
        source_lang = data.get('source_language', 'auto')
        
        if not text:
            return jsonify({'error': 'Text cannot be empty'}), 400
        
        translated_text = chatbot.translator.translate(text, target_lang, source_lang)
        
        return jsonify({
            'translated_text': translated_text,
            'source_language': source_lang,
            'target_language': target_lang
        })
        
    except Exception as e:
        logger.error(f"Translation error: {str(e)}")
        return jsonify({'error': 'Translation failed'}), 500

@app.route('/languages')
def get_supported_languages():
    """Get list of supported languages"""
    return jsonify(chatbot.supported_languages)

@app.route('/health')
def health_check():
    """Health check endpoint"""
    return jsonify({
        'status': 'healthy',
        'timestamp': datetime.now().isoformat(),
        'version': '2.0.0',
        'features': [
            'voice_processing',
            'sentiment_analysis',
            'conversation_memory',
            'document_analysis',
            'collaboration',
            'analytics',
            'personality_customization',
            'multimodal_input'
        ]
    })

# Advanced Feature Endpoints

@app.route('/voice/speech-to-text', methods=['POST'])
def speech_to_text():
    """Convert speech to text"""
    try:
        if 'audio' not in request.files:
            return jsonify({'error': 'No audio file provided'}), 400
        
        audio_file = request.files['audio']
        language = request.form.get('language', 'en')
        
        # Save audio temporarily
        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
            audio_file.save(temp_file.name)
            
            # Process audio
            text = chatbot.voice_processor.recognize_speech_from_file(temp_file.name, language)
            
            # Clean up
            os.unlink(temp_file.name)
        
        if text:
            return jsonify({
                'text': text,
                'language': language,
                'confidence': 0.85
            })
        else:
            return jsonify({'error': 'Could not recognize speech'}), 400
            
    except Exception as e:
        logger.error(f"Speech to text error: {str(e)}")
        return jsonify({'error': 'Speech recognition failed'}), 500

@app.route('/voice/text-to-speech', methods=['POST'])
def text_to_speech():
    """Convert text to speech"""
    try:
        data = request.get_json()
        text = data.get('text', '').strip()
        language = data.get('language', 'en')
        
        if not text:
            return jsonify({'error': 'Text cannot be empty'}), 400
        
        # Generate speech
        audio_bytes = chatbot.voice_processor.text_to_speech(text, language)
        
        if audio_bytes:
            audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
            return jsonify({
                'audio': audio_base64,
                'format': 'wav',
                'language': language
            })
        else:
            return jsonify({'error': 'Speech generation failed'}), 500
            
    except Exception as e:
        logger.error(f"Text to speech error: {str(e)}")
        return jsonify({'error': 'Speech generation failed'}), 500

@app.route('/sentiment/analyze', methods=['POST'])
def analyze_sentiment():
    """Analyze sentiment of text"""
    try:
        data = request.get_json()
        text = data.get('text', '').strip()
        language = data.get('language', 'en')
        
        if not text:
            return jsonify({'error': 'Text cannot be empty'}), 400
        
        # Analyze sentiment
        sentiment_result = chatbot.sentiment_analyzer.analyze_sentiment(text, language)
        emotion_result = chatbot.sentiment_analyzer.detect_emotions(text, language)
        
        return jsonify({
            'sentiment': sentiment_result,
            'emotions': emotion_result,
            'text': text,
            'language': language
        })
        
    except Exception as e:
        logger.error(f"Sentiment analysis error: {str(e)}")
        return jsonify({'error': 'Sentiment analysis failed'}), 500

@app.route('/memory/conversation', methods=['GET'])
def get_conversation_memory():
    """Get conversation history"""
    try:
        user_id = request.args.get('user_id', 'default')
        limit = int(request.args.get('limit', 20))
        
        history = chatbot.conversation_memory.get_conversation_history(user_id, limit)
        
        return jsonify({
            'user_id': user_id,
            'history': history,
            'count': len(history)
        })
        
    except Exception as e:
        logger.error(f"Conversation memory error: {str(e)}")
        return jsonify({'error': 'Failed to get conversation history'}), 500

@app.route('/document/analyze', methods=['POST'])
def analyze_document():
    """Analyze uploaded document"""
    try:
        if 'file' not in request.files:
            return jsonify({'error': 'No file provided'}), 400
        
        file = request.files['file']
        user_id = request.form.get('user_id', 'default')
        
        if file.filename == '':
            return jsonify({'error': 'No file selected'}), 400
        
        # Check if file format is supported
        if not chatbot.document_analyzer.is_supported_format(file.filename):
            return jsonify({'error': 'Unsupported file format'}), 400
        
        # Read file bytes
        file_bytes = file.read()
        
        # Analyze document
        result = chatbot.document_analyzer.analyze_document_from_bytes(
            file_bytes, file.filename, user_id
        )
        
        return jsonify(result)
        
    except Exception as e:
        logger.error(f"Document analysis error: {str(e)}")
        return jsonify({'error': 'Document analysis failed'}), 500

@app.route('/collaboration/rooms', methods=['GET'])
def get_collaboration_rooms():
    """Get available collaboration rooms"""
    try:
        rooms = chatbot.collaboration_manager.get_public_rooms()
        return jsonify({'rooms': rooms})
        
    except Exception as e:
        logger.error(f"Collaboration rooms error: {str(e)}")
        return jsonify({'error': 'Failed to get rooms'}), 500

@app.route('/collaboration/room/create', methods=['POST'])
def create_collaboration_room():
    """Create new collaboration room"""
    try:
        data = request.get_json()
        name = data.get('name', '').strip()
        creator_id = data.get('creator_id', 'default')
        description = data.get('description', '')
        is_public = data.get('is_public', True)
        
        if not name:
            return jsonify({'error': 'Room name cannot be empty'}), 400
        
        result = chatbot.collaboration_manager.create_room(
            name, creator_id, description, is_public
        )
        
        return jsonify(result)
        
    except Exception as e:
        logger.error(f"Create room error: {str(e)}")
        return jsonify({'error': 'Failed to create room'}), 500

@app.route('/analytics/dashboard', methods=['GET'])
def get_analytics_dashboard():
    """Get analytics dashboard data"""
    try:
        days = int(request.args.get('days', 7))
        
        # Get various analytics
        user_analytics = chatbot.analytics_engine.get_user_analytics(days=days)
        conversation_analytics = chatbot.analytics_engine.get_conversation_analytics(days=days)
        system_analytics = chatbot.analytics_engine.get_system_analytics(days=days)
        real_time_metrics = chatbot.analytics_engine.get_real_time_metrics()
        
        return jsonify({
            'user_analytics': user_analytics,
            'conversation_analytics': conversation_analytics,
            'system_analytics': system_analytics,
            'real_time_metrics': real_time_metrics,
            'period_days': days
        })
        
    except Exception as e:
        logger.error(f"Analytics dashboard error: {str(e)}")
        return jsonify({'error': 'Failed to get analytics'}), 500

@app.route('/personality/profiles', methods=['GET'])
def get_personality_profiles():
    """Get available personality profiles"""
    try:
        profiles = chatbot.personality_engine.get_available_profiles()
        current_profile = chatbot.personality_engine.get_current_profile()
        
        return jsonify({
            'available_profiles': profiles,
            'current_profile': current_profile
        })
        
    except Exception as e:
        logger.error(f"Personality profiles error: {str(e)}")
        return jsonify({'error': 'Failed to get profiles'}), 500

@app.route('/personality/set', methods=['POST'])
def set_personality_profile():
    """Set personality profile"""
    try:
        data = request.get_json()
        profile_id = data.get('profile_id')
        user_id = data.get('user_id', 'default')
        
        if not profile_id:
            return jsonify({'error': 'Profile ID is required'}), 400
        
        result = chatbot.personality_engine.set_personality_profile(profile_id, user_id)
        
        return jsonify(result)
        
    except Exception as e:
        logger.error(f"Set personality error: {str(e)}")
        return jsonify({'error': 'Failed to set personality'}), 500

@app.route('/multimodal/process', methods=['POST'])
def process_multimodal_input():
    """Process multi-modal input"""
    try:
        data = request.get_json()
        input_type = data.get('type')
        content = data.get('content')
        metadata = data.get('metadata', {})
        user_id = data.get('user_id', 'default')
        
        if not input_type or not content:
            return jsonify({'error': 'Input type and content are required'}), 400
        
        # Validate input
        validation = chatbot.multimodal_processor.validate_input(data)
        if not validation['is_valid']:
            return jsonify({
                'error': 'Invalid input',
                'details': validation['errors']
            }), 400
        
        # Process input
        result = chatbot.multimodal_processor.process_input(data, user_id)
        
        return jsonify(result)
        
    except Exception as e:
        logger.error(f"Multi-modal processing error: {str(e)}")
        return jsonify({'error': 'Multi-modal processing failed'}), 500

if __name__ == '__main__':
    # Load configuration
    from config import get_config
    
    config_class = get_config()
    app.config.from_object(config_class)
    config_class.init_app(app)
    
    # Load environment variables
    openai.api_key = os.getenv('OPENAI_API_KEY') or config_class.OPENAI_API_KEY
    
    if not openai.api_key:
        logger.warning("OpenAI API key not found. Please set OPENAI_API_KEY environment variable.")
    
    app.run(debug=config_class.DEBUG, host=config_class.HOST, port=config_class.PORT)