import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
import joblib
import os
import sys
import pickle

# Add the project root to Python path
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
sys.path.append(project_root)

class LiverDiseaseModel:
    # In the __init__ method, add more detailed error handling
    def __init__(self):
        self.model = None
        self.scaler = None
        self.model_path = os.path.join(project_root, "models", "liver_model.joblib")
        self.scaler_path = os.path.join(project_root, "models", "liver_scaler.joblib")
        self.pkl_model_path = os.path.join(project_root, "models", "liver_disease_model.pkl")
        
        # Create models directory if it doesn't exist
        os.makedirs(os.path.dirname(self.model_path), exist_ok=True)
        
        print(f"Looking for model at: {self.pkl_model_path}")
        
        # Try to load model and scaler in this order:
        # 1. First try the .pkl file
        # 2. Then try the .joblib files
        if os.path.exists(self.pkl_model_path):
            try:
                print(f"Loading model from {self.pkl_model_path}")
                with open(self.pkl_model_path, 'rb') as f:
                    model_data = pickle.load(f)
                    
                # Check if the loaded data is a dictionary containing both model and scaler
                if isinstance(model_data, dict):
                    self.model = model_data.get('model')
                    self.scaler = model_data.get('scaler')
                    print("Successfully loaded model and scaler from .pkl file")
                else:
                    # If it's just the model
                    self.model = model_data
                    print("Loaded model from .pkl file, but no scaler found")
                    
                    # Try to load scaler separately if it exists
                    if os.path.exists(self.scaler_path):
                        self.scaler = joblib.load(self.scaler_path)
                        print("Loaded scaler from .joblib file")
                    else:
                        # Create a default scaler if none exists
                        print("No scaler found, creating a default StandardScaler")
                        self.scaler = StandardScaler()
            except Exception as e:
                print(f"Error loading model from .pkl file: {str(e)}")
                import traceback
                print(traceback.format_exc())
        else:
            print(f"Model file not found at: {self.pkl_model_path}")
    
    def train(self, X, y):
        """Train the model on the provided data"""
        # Split the data
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        
        # Initialize and fit the scaler
        self.scaler = StandardScaler()
        X_train_scaled = self.scaler.fit_transform(X_train)
        
        # Initialize and train the model
        self.model = RandomForestClassifier(
            n_estimators=100,
            max_depth=10,
            random_state=42
        )
        self.model.fit(X_train_scaled, y_train)
        
        # Save the model and scaler in both formats
        joblib.dump(self.model, self.model_path)
        joblib.dump(self.scaler, self.scaler_path)
        
        # Also save as .pkl for compatibility
        with open(self.pkl_model_path, 'wb') as f:
            pickle.dump({'model': self.model, 'scaler': self.scaler}, f)
        
        # Evaluate on test set
        X_test_scaled = self.scaler.transform(X_test)
        test_score = self.model.score(X_test_scaled, y_test)
        return test_score
    
    def predict(self, features):
        """Make a prediction for the given features"""
        if self.model is None:
            raise ValueError(f"Model not loaded. Please ensure model file exists at {self.pkl_model_path} and is valid.")
        
        if self.scaler is None:
            print("Warning: No scaler found. Using raw features without scaling.")
        
        # Convert features to DataFrame
        feature_names = ['Age', 'Gender', 'Total_Bilirubin', 'Direct_Bilirubin', 
                        'Alkaline_Phosphotase', 'Alamine_Aminotransferase', 
                        'Aspartate_Aminotransferase', 'Total_Protiens', 
                        'Albumin', 'Albumin_and_Globulin_Ratio']
        
        # Create a DataFrame with the features in the correct order
        df = pd.DataFrame([features], columns=feature_names)
        
        # Scale the features if scaler is available
        if self.scaler is not None:
            try:
                X_scaled = self.scaler.transform(df)
            except Exception as e:
                print(f"Error scaling features: {str(e)}. Using raw features.")
                X_scaled = df.values
        else:
            X_scaled = df.values
        
        # Make prediction
        try:
            prediction = bool(self.model.predict(X_scaled)[0])
            probability = float(self.model.predict_proba(X_scaled)[0][1])
        except Exception as e:
            print(f"Error making prediction: {str(e)}")
            import traceback
            print(traceback.format_exc())
            raise ValueError(f"Error making prediction: {str(e)}")
        
        return {
            "prediction": prediction,
            "probability": probability
        }
        
    def get_feature_importance(self):
        """Return feature importance if available"""
        if self.model is None:
            return None
            
        try:
            # Get feature importance from the model
            if hasattr(self.model, 'feature_importances_'):
                return self.model.feature_importances_.tolist()
            return None
        except:
            return None