"""
Intent Model Module - Intent Classification
"""

import pickle
import os
import logging
from typing import Dict, Tuple

logger = logging.getLogger(__name__)


class IntentModel:
    """
    Intent Classification Model Wrapper
    """
    
    def __init__(self, model_path: str = 'app/model'):
        self.model_path = model_path
        self.model = None
        self.vectorizer = None
        self.label_to_intent = {}
        self._load_model()
    
    def _load_model(self):
        """Load model, vectorizer, dan label mappings"""
        try:
            model_file = os.path.join(self.model_path, 'intent_model.pkl')
            vectorizer_file = os.path.join(self.model_path, 'vectorizer.pkl')
            mappings_file = os.path.join(self.model_path, 'label_mappings.pkl')
            
            if not all(os.path.exists(f) for f in [model_file, vectorizer_file, mappings_file]):
                logger.warning("⚠️ Model files not found. Models belum dilatih.")
                return False
            
            with open(model_file, 'rb') as f:
                self.model = pickle.load(f)
            
            with open(vectorizer_file, 'rb') as f:
                self.vectorizer = pickle.load(f)
            
            with open(mappings_file, 'rb') as f:
                mappings = pickle.load(f)
                self.label_to_intent = mappings['label_to_intent']
            
            logger.info("✓ Model loaded successfully")
            return True
            
        except Exception as e:
            logger.error(f"❌ Failed to load model: {str(e)}")
            return False
    
    def is_loaded(self) -> bool:
        """Check apakah model sudah loaded"""
        return self.model is not None and self.vectorizer is not None
    
    def classify(self, text: str, threshold: float = 0.5) -> Dict:
        """
        Classify intent dari text
        
        Args:
            text: Input text dari user
            threshold: Confidence threshold (default 0.5)
        
        Returns:
            Dict dengan intent, confidence, dan is_confident
        """
        if not self.is_loaded():
            return {
                'intent': None,
                'confidence': 0.0,
                'is_confident': False,
                'error': 'Model not loaded'
            }
        
        try:
            # Preprocessing
            text_clean = text.lower().strip()
            
            # Vectorize
            X = self.vectorizer.transform([text_clean])
            
            # Predict
            label = self.model.predict(X)[0]
            confidence = self.model.predict_proba(X)[0][label]
            intent = self.label_to_intent.get(label, 'unknown')
            
            return {
                'intent': intent,
                'confidence': float(confidence),
                'is_confident': float(confidence) >= threshold
            }
            
        except Exception as e:
            logger.error(f"❌ Classification error: {str(e)}")
            return {
                'intent': None,
                'confidence': 0.0,
                'is_confident': False,
                'error': str(e)
            }