import streamlit as st
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

class MachineLearning:
    def perform_ml_tasks(self, df):
        task_type = st.selectbox("Select ML task", ["Classification", "Clustering", "Dimensionality Reduction"])
        
        if task_type == "Classification":
            self.perform_classification(df)
        elif task_type == "Clustering":
            self.perform_clustering(df)
        elif task_type == "Dimensionality Reduction":
            self.perform_dimensionality_reduction(df)

    def perform_classification(self, df):
        target_column = st.selectbox("Select target column", df.columns)
        feature_columns = st.multiselect("Select feature columns", df.columns.drop(target_column))
        
        if len(feature_columns) > 0:
            X = df[feature_columns]
            y = df[target_column]
            
            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
            
            scaler = StandardScaler()
            X_train_scaled = scaler.fit_transform(X_train)
            X_test_scaled = scaler.transform(X_test)
            
            model_type = st.selectbox("Select model type", ["Logistic Regression", "Decision Tree", "Random Forest", "SVM"])
            
            if model_type == "Logistic Regression":
                model = LogisticRegression()
            elif model_type == "Decision Tree":
                model = DecisionTreeClassifier()
            elif model_type == "Random Forest":
                model = RandomForestClassifier()
            elif model_type == "SVM":
                model = SVC()
            
            model.fit(X_train_scaled, y_train)
            y_pred = model.predict(X_test_scaled)
            
            st.subheader("Classification Results")
            st.write(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")
            st.write("Classification Report:")
            st.code(classification_report(y_test, y_pred))

    def perform_clustering(self, df):
        feature_columns = st.multiselect("Select feature columns for clustering", df.columns)
        
        if len(feature_columns) > 0:
            X = df[feature_columns]
            
            scaler = StandardScaler()
            X_scaled = scaler.fit_transform(X)
            
            n_clusters = st.slider("Select number of clusters", min_value=2, max_value=10, value=3)
            
            kmeans = KMeans(n_clusters=n_clusters, random_state=42)
            cluster_labels = kmeans.fit_predict(X_scaled)
            
            df['Cluster'] = cluster_labels
            
            st.subheader("Clustering Results")
            if len(feature_columns) >= 2:
                fig = px.scatter(df, x=feature_columns[0], y=feature_columns[1], color='Cluster')
                st.plotly_chart(fig)
            
            st.write("Cluster Centers:")
            cluster_centers = scaler.inverse_transform(kmeans.cluster_centers_)
            st.write(pd.DataFrame(cluster_centers, columns=feature_columns))

    def perform_dimensionality_reduction(self, df):
        feature_columns = st.multiselect("Select feature columns for dimensionality reduction", df.columns)
        
        if len(feature_columns) > 0:
            X = df[feature_columns]
            
            scaler = StandardScaler()
            X_scaled = scaler.fit_transform(X)
            
            n_components = st.slider("Select number of components", min_value=2, max_value=min(len(feature_columns), 10), value=2)
            
            pca = PCA(n_components=n_components)
            X_pca = pca.fit_transform(X_scaled)
            
            st.subheader("PCA Results")
            explained_variance_ratio = pca.explained_variance_ratio_
            st.write(f"Explained Variance Ratio: {explained_variance_ratio}")
            
            if n_components >= 2:
                fig = px.scatter(x=X_pca[:, 0], y=X_pca[:, 1], title="PCA Visualization")
                st.plotly_chart(fig)
            
            st.write("PCA Components:")
            st.write(pd.DataFrame(pca.components_, columns=feature_columns))