#!/usr/bin/env python3
"""
method_split.py

Author: natelgrw
Last Edited: 11/04/2025

Splits the ReTiNA dataset into 5 folds based on LC-MS setup configurations 
(e.g., solvents, gradient, column, temperature, flow rate).
Each setup group is assigned to a single fold to avoid data leakage 
across similar chromatographic conditions.
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from pathlib import Path
from collections import defaultdict
import random
import umap
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.cluster import KMeans
from ast import literal_eval


# ===== Configuration ===== #


INPUT_CSV = "../retina_dataset.csv"
METHOD_CSV = "../lcms_methods.csv"
OUTPUT_DIR = "../method_split"
N_FOLDS = 5
RANDOM_SEED = 42

random.seed(RANDOM_SEED)
np.random.seed(RANDOM_SEED)


# ===== Helper Functions ===== #


def analyze_dataset(df):
    """
    Prints dataset statistics.
    """
    print("=" * 70)
    print("Dataset Analysis")
    print("=" * 70)
    print(f"Total rows: {len(df):,}")
    if "compound" in df.columns:
        print(f"Unique compounds: {df['compound'].nunique():,}")
    if 'rt' in df.columns:
        print(f"\nRetention Time Stats:")
        print(f"  Mean: {df['rt'].mean():.2f} s | Median: {df['rt'].median():.2f} s")
    if 'method_number' in df.columns:
        print(f"Unique methods: {df['method_number'].nunique():,}")
    print()


def assign_methods_to_folds(method_sizes, n_folds, method_features=None, method_ids=None):
    """
    Assigns methods to folds using KMeans clustering on UMAP coordinates.
    This creates compact, spatially-separated regions in the UMAP visualization.
    """
    fold_assignments = defaultdict(list)
    fold_counts = [0] * n_folds

    if method_features is not None and method_ids is not None:
        print(f"\nUsing KMeans to create {n_folds} spatially-separated regions...")
        
        kmeans = KMeans(n_clusters=n_folds, random_state=RANDOM_SEED, n_init=20)
        cluster_labels = kmeans.fit_predict(method_features)
        
        cluster_to_methods = defaultdict(list)
        for method_id, cluster_id in zip(method_ids, cluster_labels):
            cluster_to_methods[cluster_id].append(method_id)
        
        cluster_sizes = {}
        for cluster_id, methods in cluster_to_methods.items():
            cluster_sizes[cluster_id] = sum(method_sizes[m] for m in methods)
        
        total_size = sum(method_sizes.values())
        avg_size = total_size / n_folds
        
        print(f"Target size per fold: {avg_size:,.0f} datapoints")
        
        for cluster_id, methods in cluster_to_methods.items():
            cluster_size = cluster_sizes[cluster_id]
            method_size_list = [(m, method_sizes[m]) for m in methods]
            method_size_list.sort(key=lambda x: x[1], reverse=True)
            
            if len(method_size_list) > 0:
                largest_method, largest_size = method_size_list[0]
                if largest_size > cluster_size * 0.6 and largest_size > avg_size * 0.5:
                    print(f"Warning: Method {largest_method} has {largest_size:,} datapoints "
                          f"({100*largest_size/total_size:.1f}% of total dataset)")
        
        for cluster_id in range(n_folds):
            methods = cluster_to_methods[cluster_id]
            for method in methods:
                fold_assignments[cluster_id].append(method)
                fold_counts[cluster_id] += method_sizes[method]
        
        print("\nSpatial assignment complete!")
        print(f"Largest fold: {max(fold_counts):,} datapoints")
        print(f"Smallest fold: {min(fold_counts):,} datapoints")
        print(f"Fold size ratio: {max(fold_counts)/min(fold_counts):.2f}x")
        
    else:
        print("\nWarning: No method features provided, using greedy assignment")
        sorted_methods = sorted(method_sizes.items(), key=lambda x: x[1], reverse=True)
        for method, size in sorted_methods:
            min_fold = min(range(n_folds), key=lambda i: fold_counts[i])
            fold_assignments[min_fold].append(method)
            fold_counts[min_fold] += size

    return fold_assignments, fold_counts


# ===== Analyzer Class ===== #


class MethodAnalyzer:
    """
    Analyzer for LC-MS setup-based splitting.
    """

    def __init__(self, data_path, method_path, output_dir):
        self.data_path = Path(data_path)
        self.method_path = Path(method_path)
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True, parents=True)
        self.df = None
        self.methods = None

    def load_data(self):
        """
        Loads the datasets.
        """
        print("\nLOADING RETINA + METHOD DATA")
        self.df = pd.read_csv(self.data_path)
        self.methods = pd.read_csv(self.method_path)

        for col in ["gradient", "column"]:
            if col in self.methods.columns:
                self.methods[col] = self.methods[col].apply(lambda x: literal_eval(x) if isinstance(x, str) else x)
        print(f"Loaded {len(self.df):,} datapoints and {len(self.methods):,} methods.")

    def extract_method_features(self):
        """
        Converts LC-MS setups into numerical feature vectors.
        """
        if hasattr(self, 'method_features_X'):
            return self.method_features_X
            
        df = self.methods.copy()
        df["phase"] = df["column"].apply(lambda x: x[0] if isinstance(x, list) else "UNK")
        df["col_diam"] = df["column"].apply(lambda x: float(x[1]) if isinstance(x, list) else 0)
        df["col_len"] = df["column"].apply(lambda x: float(x[2]) if isinstance(x, list) else 0)
        df["col_part"] = df["column"].apply(lambda x: float(x[3]) if isinstance(x, list) else 0)
        df["grad_len"] = df["gradient"].apply(lambda x: x[-1][0] if isinstance(x, list) and len(x) > 0 else 0)
        df["grad_range"] = df["gradient"].apply(
            lambda x: max([p[1] for p in x]) - min([p[1] for p in x]) if isinstance(x, list) and len(x) > 0 else 0
        )

        feat_cols = ["phase", "col_diam", "col_len", "col_part", "grad_len", "grad_range", "flow_rate", "temp"]
        cat_cols = ["phase"]
        num_cols = [c for c in feat_cols if c not in cat_cols]

        preprocessor = ColumnTransformer([
            ("cat", OneHotEncoder(), cat_cols),
            ("num", StandardScaler(), num_cols)
        ])

        X = preprocessor.fit_transform(df[feat_cols])
        df["vector"] = list(X.toarray() if hasattr(X, "toarray") else X)
        print(f"Extracted {X.shape[1]} features per method.")
        self.methods = df
        self.method_features_X = X
        return X

    def create_method_splits(self, n_splits=5):
        """
        Splits the dataset by LC-MS setup groups into folds.
        """
        print("\nCREATING METHOD SPLITS")
        print("=" * 60)

        print("Extracting method features and computing UMAP...")
        X = self.extract_method_features()
        
        # compute UMAP embedding
        reducer = umap.UMAP(
            n_neighbors=8,
            min_dist=0.1,
            metric="euclidean",
            random_state=RANDOM_SEED
        )
        umap_embedding = reducer.fit_transform(X)
        self.methods["umap_x"], self.methods["umap_y"] = umap_embedding[:, 0], umap_embedding[:, 1]
        print("UMAP embedding computed.")
        
        method_ids = self.methods["method_number"].values
        
        method_sizes = self.df["method_number"].value_counts().to_dict()
        print(f"{len(method_sizes):,} unique methods in dataset.")

        fold_assignments, fold_counts = assign_methods_to_folds(
            method_sizes, n_splits, 
            method_features=umap_embedding,
            method_ids=method_ids
        )
        
        print("\nFold balance summary:")
        for i, count in enumerate(fold_counts):
            print(f"  Fold {i+1}: {count:,} datapoints ({100*count/len(self.df):.2f}%)")

        method_to_fold = {}
        for i, methods in fold_assignments.items():
            for m in methods:
                method_to_fold[m] = i + 1

        self.df["fold"] = self.df["method_number"].map(method_to_fold)
        
        self.methods["fold"] = self.methods["method_number"].map(method_to_fold)

        fold_dataframes = {}
        for i in range(n_splits):
            fold_df = self.df[self.df["fold"] == i + 1].copy()
            out_file = self.output_dir / f"methods_{i+1}.csv"
            fold_df.to_csv(out_file, index=False)
            fold_dataframes[i] = fold_df
            print(f"Saved setup_{i+1}.csv ({len(fold_df):,} rows)")

        return fold_dataframes

    def visualize_rt_distributions(self, fold_dataframes):
        """
        Generates a KDE plot of the RT distribution per setup split.
        """
        print("\nPLOTTING RETENTION TIME DISTRIBUTIONS")
        fig, ax = plt.subplots(figsize=(14, 6))
        colors = sns.color_palette("husl", len(fold_dataframes))

        if "rt" in self.df.columns:
            overall_rt = self.df["rt"].dropna() / 60.0
            if len(overall_rt) > 0:
                sns.kdeplot(
                    overall_rt, ax=ax, 
                    color='black', linewidth=2.5, 
                    linestyle='--', 
                    label=f"Overall (n={len(overall_rt):,})"
                )

        for i, fold_df in fold_dataframes.items():
            if "rt" not in fold_df.columns:
                continue
            rt_min = fold_df["rt"].dropna() / 60.0
            if len(rt_min) > 0:
                sns.kdeplot(
                    rt_min, ax=ax, 
                    label=f"Setup {i+1} (n={len(rt_min):,})", 
                    color=colors[i], 
                    linewidth=2.5
                )

        ax.set_xlabel("Retention Time (min)", fontsize=12, fontweight='bold')
        ax.set_ylabel("Density", fontsize=12, fontweight='bold')
        ax.set_title("Retention Time Distribution Across Method Splits", fontsize=14, fontweight='bold')
        ax.legend(fontsize=10, framealpha=0.9)
        ax.grid(alpha=0.3, linestyle=':', linewidth=0.5)
        ax.set_xlim(left=0)

        fig_dir = self.output_dir / "figures"
        fig_dir.mkdir(exist_ok=True)
        plt.savefig(fig_dir / "methods_rt.png", dpi=300, bbox_inches="tight")
        plt.close()
        print(f"Saved RT KDE plot to figures/method_rt.png")

    def generate_umap_plot(self):
        """
        Generates a UMAP visualization plot (embedding already computed).
        """
        print("\nGENERATING UMAP VISUALIZATION")
        
        if "umap_x" not in self.methods.columns or "umap_y" not in self.methods.columns:
            print("Warning: UMAP coordinates not found, computing now...")
            X = self.extract_method_features()
            reducer = umap.UMAP(
                n_neighbors=8,
                min_dist=0.1,
                metric="euclidean",
                random_state=RANDOM_SEED
            )
            embedding = reducer.fit_transform(X)
            self.methods["umap_x"], self.methods["umap_y"] = embedding[:, 0], embedding[:, 1]
        
        plt.figure(figsize=(10, 7))
        
        if "fold" in self.methods.columns:
            colors = sns.color_palette("husl", N_FOLDS)
            for fold_num in sorted(self.methods["fold"].dropna().unique()):
                fold_data = self.methods[self.methods["fold"] == fold_num]
                n_methods = len(fold_data)
                plt.scatter(
                    fold_data["umap_x"], fold_data["umap_y"],
                    label=f"Cluster {int(fold_num)} (n={n_methods} methods)",
                    s=100, alpha=0.7, edgecolor="k", linewidth=0.5,
                    color=colors[int(fold_num) - 1]
                )
            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10)
            plt.title("UMAP Projection of LC-MS Method Space (Colored by Method Split)", fontsize=14, pad=15, fontweight='bold')
        else:
            sns.scatterplot(
                x="umap_x", y="umap_y", data=self.methods,
                s=70, color="steelblue", edgecolor="k"
            )
            plt.title("2D UMAP Visualization of LC-MS Method Space", fontsize=14, pad=15)

        plt.tight_layout()

        fig_dir = self.output_dir / "figures"
        fig_dir.mkdir(exist_ok=True)
        plt.savefig(fig_dir / "methods_umap.png", dpi=300, bbox_inches="tight")
        plt.close()
        print(f"Saved UMAP plot to figures/method_umap.png")


# ===== Main ===== #


def main():
    """
    Main execution function.
    """
    print("\n" + "=" * 80)
    print(" " * 30 + "METHOD SPLIT PIPELINE")
    print("=" * 80)

    analyzer = MethodAnalyzer(INPUT_CSV, METHOD_CSV, OUTPUT_DIR)
    analyzer.load_data()
    analyze_dataset(analyzer.df)
    
    fold_dataframes = analyzer.create_method_splits(n_splits=N_FOLDS)
    
    analyzer.generate_umap_plot()
    
    analyzer.visualize_rt_distributions(fold_dataframes)

    print("\n" + "=" * 80)
    print(" " * 30 + "METHOD SPLIT COMPLETE!")
    print("=" * 80)


if __name__ == "__main__":
    main()