app.py

import os
import pandas as pd
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.neighbors import NearestNeighbors
from sklearn.decomposition import TruncatedSVD, NMF
from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from scipy.sparse import csr_matrix
from scipy.spatial.distance import pdist, squareform
import gradio as gr
import json
import re
from collections import defaultdict, Counter
import csv
import time
from datetime import datetime
import warnings
warnings.filterwarnings('ignore')

# Importar huggingface_hub para descargar archivos
from huggingface_hub import hf_hub_download

# ==================== CARGA DE DATOS DESDE HUGGING FACE ====================

def download_file_from_hf(filename, repo_id="aegarciaherrera/Sistema_Recomendador_Archivos"):
    """
    Descarga un archivo específico desde el repositorio de Hugging Face
    """
    try:
        file_path = hf_hub_download(
            repo_id=repo_id,
            filename=filename,
            repo_type="dataset"
        )
        print(f"✓ Archivo {filename} descargado exitosamente")
        return file_path
    except Exception as e:
        print(f"✗ Error descargando {filename}: {str(e)}")
        return None

# Descargar archivos principales
print("Descargando archivos desde Hugging Face...")
productos_path = download_file_from_hf("productos.csv")
mapping_path = download_file_from_hf("embedding_index_mapping.csv")

# Cargar datos principales
if productos_path and mapping_path:
    df_productos = pd.read_csv(productos_path)
    df_productos = df_productos.reset_index(drop=True)
    df_mapping = pd.read_csv(mapping_path)
    print(f"✓ Productos cargados: {len(df_productos):,} registros")
    print(f"✓ Mapping cargado: {len(df_mapping):,} registros")
else:
    raise FileNotFoundError("No se pudieron descargar los archivos principales")

# Cargar ratings (adaptable a ambos formatos)
try:
    # Intentar cargar ratings agregados (V2)
    ratings_agg_path = download_file_from_hf("ratings_aggregated.csv")
    ratings_det_path = download_file_from_hf("ratings_detailed.csv")
    
    if ratings_agg_path and ratings_det_path:
        df_ratings_aggregated = pd.read_csv(ratings_agg_path)
        df_ratings_detailed = pd.read_csv(ratings_det_path)
        ratings_dict = df_ratings_aggregated.set_index('parent_asin')['average_rating'].to_dict()
        print(f"✓ Ratings V2 cargados: {len(ratings_dict):,} productos con ratings")
        HAS_DETAILED_RATINGS = True
    else:
        raise FileNotFoundError("Archivos V2 no encontrados")
        
except Exception as e:
    print(f"No se pudieron cargar ratings V2: {str(e)}")
    try:
        # Fallback a ratings V1
        ratings_path = download_file_from_hf("ratings.csv")
        if ratings_path:
            df_ratings = pd.read_csv(ratings_path)
            ratings_dict = df_ratings.set_index('parent_asin')['rating'].to_dict()
            df_ratings_detailed = df_ratings  # Para compatibilidad
            print(f"✓ Ratings V1 cargados: {len(ratings_dict):,} productos con ratings")
            HAS_DETAILED_RATINGS = False
        else:
            raise FileNotFoundError("No se pudo cargar ratings V1")
    except Exception as e2:
        print(f"✗ Error cargando ratings: {str(e2)}")
        ratings_dict = {}
        df_ratings_detailed = pd.DataFrame()
        HAS_DETAILED_RATINGS = False

print("=" * 50)
print("RESUMEN DE CARGA:")
print(f"- Productos: {len(df_productos):,} registros")
print(f"- Ratings: {len(ratings_dict):,} productos")
print(f"- Ratings detallados: {'Sí' if HAS_DETAILED_RATINGS else 'No'}")
print("=" * 50)

# ==================== PREPARACIÓN DE DATOS (SIN MERGE) ====================
# CRÍTICO: No hacer merge para preservar embeddings precargados
df_similars = df_productos[df_productos["parent_asin"].isin(df_mapping["parent_asin"])].reset_index(drop=True)

# Asegurarte de que el orden coincida
df_similars = df_similars.merge(df_mapping, on="parent_asin").sort_values("index").reset_index(drop=True)

# CRÍTICO: Resetear índices ANTES de cualquier operación
df_similars["description"] = df_similars["description"].fillna("").astype(str)
df_similars = df_similars.reset_index(drop=True)

print(f"Total de productos en df_similars: {len(df_similars):,}")
print(f"Productos únicos: {df_similars['parent_asin'].nunique():,}")

# ==================== CARGA DE EMBEDDINGS ====================
model = SentenceTransformer("all-MiniLM-L6-v2")

# Descargar embeddings precomputados desde Hugging Face
try:
    embeddings_path = download_file_from_hf("embeddings.npy")
    descriptions_path = download_file_from_hf("descriptions.npy")
    
    if embeddings_path and descriptions_path:
        description_embeddings = np.load(embeddings_path)
        descriptions = np.load(descriptions_path, allow_pickle=True)
        print(f"✓ Embeddings precalculados descargados y cargados: {description_embeddings.shape}")
        
        # VERIFICACIÓN CRÍTICA: Asegurar consistencia
        if len(description_embeddings) != len(df_similars):
            print(f"WARNING: Mismatch detectado!")
            print(f"   Embeddings: {len(description_embeddings)}")
            print(f"   df_similars: {len(df_similars)}")
            print("   Recomiendo regenerar embeddings con el nuevo df_similars")
        else:
            print("✓ Consistencia verificada: embeddings y df_similars coinciden")
    else:
        raise FileNotFoundError("No se pudieron descargar los embeddings precomputados")

except Exception as e:
    print(f"✗ Error descargando embeddings: {str(e)}")
    print("Generando embeddings básicos...")
    description_embeddings = model.encode(df_similars["description"].tolist())
    descriptions = df_similars["description"].values

# ==================== SISTEMA DE MÉTRICAS Y EVALUACIÓN ====================
class RecommendationMetrics:
    """Sistema de métricas para evaluar y comparar diferentes enfoques de recomendación"""

    def __init__(self):
        self.metrics_history = defaultdict(list)
        self.execution_times = defaultdict(list)

    def calculate_diversity(self, recommendations_asins):
        """Calcula la diversidad de las recomendaciones basada en categorías"""
        if not recommendations_asins:
            return 0.0

        categories = []
        for asin in recommendations_asins:
            product_row = df_similars[df_similars['parent_asin'] == asin]
            if len(product_row) > 0:
                category = product_row.iloc[0].get('main_category', 'Unknown')
                categories.append(category)

        if not categories:
            return 0.0

        unique_categories = len(set(categories))
        total_items = len(categories)
        return unique_categories / total_items

    def calculate_novelty(self, recommendations_asins):
        """Calcula la novedad basada en popularidad (rating y frecuencia)"""
        if not recommendations_asins:
            return 0.0

        novelty_scores = []
        for asin in recommendations_asins:
            rating = ratings_dict.get(asin, 0.0)
            # Mayor rating = menor novedad (productos populares)
            novelty_score = max(0, 5.0 - rating) / 5.0
            novelty_scores.append(novelty_score)

        return np.mean(novelty_scores) if novelty_scores else 0.0

    def calculate_coverage(self, recommendations_asins, total_available_items):
        """Calcula el coverage como porcentaje de items únicos recomendados"""
        unique_recommendations = len(set(recommendations_asins))
        return unique_recommendations / min(total_available_items, 100)  # Normalizar

    def calculate_precision_at_k(self, recommendations_asins, relevant_items, k=5):
        """Calcula precision@k"""
        if not recommendations_asins or not relevant_items:
            return 0.0

        top_k = recommendations_asins[:k]
        relevant_in_top_k = len(set(top_k) & set(relevant_items))
        return relevant_in_top_k / min(k, len(top_k))

    def evaluate_recommendations(self, method_name, recommendations_asins, execution_time,
                               relevant_items=None, total_available=1000):
        """Evalúa un conjunto de recomendaciones con múltiples métricas"""
        metrics = {
            'method': method_name,
            'timestamp': datetime.now(),
            'execution_time': execution_time,
            'num_recommendations': len(recommendations_asins),
            'diversity': self.calculate_diversity(recommendations_asins),
            'novelty': self.calculate_novelty(recommendations_asins),
            'coverage': self.calculate_coverage(recommendations_asins, total_available)
        }

        if relevant_items:
            metrics['precision_at_5'] = self.calculate_precision_at_k(recommendations_asins, relevant_items, 5)

        # Almacenar métricas
        for key, value in metrics.items():
            if key not in ['method', 'timestamp']:
                self.metrics_history[f"{method_name}_{key}"].append(value)

        return metrics

    def get_comparison_report(self):
        """Genera un reporte comparativo de todos los métodos evaluados"""
        if not self.metrics_history:
            return "No hay métricas disponibles"

        report = "# 📊 REPORTE COMPARATIVO DE MÉTODOS\n\n"

        # Agrupar métricas por tipo
        methods = set()
        for key in self.metrics_history.keys():
            method = key.split('_')[0] + '_' + key.split('_')[1]
            methods.add(method)

        for method in sorted(methods):
            report += f"## {method.replace('_', ' ').title()}\n"

            # Buscar métricas de este método
            method_metrics = {}
            for key, values in self.metrics_history.items():
                if key.startswith(method):
                    metric_name = '_'.join(key.split('_')[2:])
                    if values:
                        method_metrics[metric_name] = {
                            'mean': np.mean(values),
                            'std': np.std(values),
                            'count': len(values)
                        }

            for metric, stats in method_metrics.items():
                report += f"- **{metric.replace('_', ' ').title()}**: {stats['mean']:.4f} ± {stats['std']:.4f} (n={stats['count']})\n"

            report += "\n"

        return report

# Instancia global de métricas
metrics_evaluator = RecommendationMetrics()

# ==================== FUNCIONALIDAD 1: BÚSQUEDA POR DESCRIPCIÓN (3 MÉTODOS) ====================

class DescriptionSearcher:
    """Sistema de búsqueda por descripción con múltiples enfoques"""

    def __init__(self, df_products, embeddings, model):
        self.df_products = df_products
        self.embeddings = embeddings
        self.model = model
        self.setup_methods()

    def setup_methods(self):
        """Configura los diferentes métodos de búsqueda"""
        # Método 1: KNN con embeddings (original)
        self.knn = NearestNeighbors(n_neighbors=50, metric="cosine")
        self.knn.fit(self.embeddings)

        # Método 2: TF-IDF + Cosine Similarity
        descriptions_text = self.df_products["description"].fillna("").tolist()
        self.tfidf_vectorizer = TfidfVectorizer(
            max_features=5000,
            stop_words='english',
            ngram_range=(1, 2),
            min_df=2
        )
        self.tfidf_matrix = self.tfidf_vectorizer.fit_transform(descriptions_text)

        # Método 3: Clustering + Embedding similarity
        self.n_clusters = min(100, len(self.df_products) // 10)
        self.kmeans = KMeans(n_clusters=self.n_clusters, random_state=42, n_init=10)
        self.cluster_labels = self.kmeans.fit_predict(self.embeddings)

    def search_method_1_knn(self, query, n_results=5):
        """Método 1: KNN con embeddings (original mejorado)"""
        start_time = time.time()

        query_embedding = self.model.encode([query])
        distances, indices = self.knn.kneighbors(query_embedding, n_neighbors=min(50, len(self.df_products)))

        results = []
        seen_asins = set()

        for i, idx in enumerate(indices[0]):
            if len(results) >= n_results:
                break

            if idx >= len(self.df_products):
                continue

            row = self.df_products.iloc[idx]
            asin = row.get("parent_asin", "N/A")

            if asin in seen_asins:
                continue
            seen_asins.add(asin)

            similarity_score = 1 - distances[0][i]  # Convertir distancia a similitud
            results.append({
                'asin': asin,
                'similarity_score': similarity_score,
                'method': 'KNN_Embeddings'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in results]
        metrics = metrics_evaluator.evaluate_recommendations(
            'search_knn', result_asins, execution_time
        )

        return results, metrics

    def search_method_2_tfidf(self, query, n_results=5):
        """Método 2: TF-IDF + Cosine Similarity"""
        start_time = time.time()

        query_tfidf = self.tfidf_vectorizer.transform([query])
        similarities = cosine_similarity(query_tfidf, self.tfidf_matrix).flatten()

        # Obtener top resultados
        top_indices = np.argsort(similarities)[::-1]

        results = []
        seen_asins = set()

        for idx in top_indices:
            if len(results) >= n_results:
                break

            if similarities[idx] < 0.01:  # Umbral mínimo de similitud
                continue

            row = self.df_products.iloc[idx]
            asin = row.get("parent_asin", "N/A")

            if asin in seen_asins:
                continue
            seen_asins.add(asin)

            results.append({
                'asin': asin,
                'similarity_score': similarities[idx],
                'method': 'TF_IDF'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in results]
        metrics = metrics_evaluator.evaluate_recommendations(
            'search_tfidf', result_asins, execution_time
        )

        return results, metrics

    def search_method_3_cluster(self, query, n_results=5):
        """Método 3: Clustering + Embedding similarity"""
        start_time = time.time()

        query_embedding = self.model.encode([query])

        # Encontrar cluster más similar
        query_cluster = self.kmeans.predict(query_embedding)[0]

        # Filtrar productos del mismo cluster
        cluster_mask = self.cluster_labels == query_cluster
        cluster_indices = np.where(cluster_mask)[0]

        if len(cluster_indices) == 0:
            execution_time = time.time() - start_time
            return [], {'method': 'Cluster_Search', 'execution_time': execution_time}

        # Calcular similitudes dentro del cluster
        cluster_embeddings = self.embeddings[cluster_indices]
        similarities = cosine_similarity(query_embedding, cluster_embeddings).flatten()

        # Ordenar por similitud
        sorted_cluster_indices = cluster_indices[np.argsort(similarities)[::-1]]

        results = []
        seen_asins = set()

        for idx in sorted_cluster_indices:
            if len(results) >= n_results:
                break

            row = self.df_products.iloc[idx]
            asin = row.get("parent_asin", "N/A")

            if asin in seen_asins:
                continue
            seen_asins.add(asin)

            similarity_idx = np.where(cluster_indices == idx)[0][0]
            similarity_score = similarities[similarity_idx]

            results.append({
                'asin': asin,
                'similarity_score': similarity_score,
                'method': 'Cluster_Search'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in results]
        metrics = metrics_evaluator.evaluate_recommendations(
            'search_cluster', result_asins, execution_time
        )

        return results, metrics

# ==================== FUNCIONALIDAD 2: RECOMENDACIÓN COLABORATIVA (3 MÉTODOS) ====================

class CollaborativeRecommender:
    """Sistema de recomendación colaborativa con múltiples enfoques"""

    def __init__(self, ratings_df, min_ratings_per_user=5, min_ratings_per_item=5):
        self.ratings_df = ratings_df.copy()
        self.min_ratings_per_user = min_ratings_per_user
        self.min_ratings_per_item = min_ratings_per_item
        self.user_item_matrix = None
        self.item_similarity_matrix = None
        self.svd_model = None
        self.nmf_model = None
        self.user_encoder = {}
        self.item_encoder = {}
        self.user_decoder = {}
        self.item_decoder = {}

        self._prepare_data()
        self._build_matrices()

    def _prepare_data(self):
        """Prepara los datos filtrando usuarios e items con pocas interacciones"""
        print("Preparando datos para filtrado colaborativo...")

        # Filtrar usuarios con al menos min_ratings_per_user ratings
        user_counts = self.ratings_df['user_id'].value_counts()
        valid_users = user_counts[user_counts >= self.min_ratings_per_user].index

        # Filtrar items con al menos min_ratings_per_item ratings
        item_counts = self.ratings_df['parent_asin'].value_counts()
        valid_items = item_counts[item_counts >= self.min_ratings_per_item].index

        # Aplicar filtros
        self.ratings_df = self.ratings_df[
            (self.ratings_df['user_id'].isin(valid_users)) &
            (self.ratings_df['parent_asin'].isin(valid_items))
        ]

        print(f"Datos filtrados: {len(self.ratings_df):,} ratings, "
              f"{self.ratings_df['user_id'].nunique():,} usuarios, "
              f"{self.ratings_df['parent_asin'].nunique():,} productos")

        # Crear encoders
        unique_users = self.ratings_df['user_id'].unique()
        unique_items = self.ratings_df['parent_asin'].unique()

        self.user_encoder = {user: idx for idx, user in enumerate(unique_users)}
        self.item_encoder = {item: idx for idx, item in enumerate(unique_items)}
        self.user_decoder = {idx: user for user, idx in self.user_encoder.items()}
        self.item_decoder = {idx: item for item, idx in self.item_encoder.items()}

    def _build_matrices(self):
        """Construye las matrices necesarias para la recomendación"""
        print("Construyendo matrices de interacción...")

        n_users = len(self.user_encoder)
        n_items = len(self.item_encoder)

        # Mapear a índices numéricos
        user_indices = self.ratings_df['user_id'].map(self.user_encoder)
        item_indices = self.ratings_df['parent_asin'].map(self.item_encoder)
        ratings = self.ratings_df['rating'].values

        # Crear matriz sparse
        self.user_item_matrix = csr_matrix(
            (ratings, (user_indices, item_indices)),
            shape=(n_users, n_items)
        )

        # Método 1: SVD para similitud entre items
        print("Calculando similitudes SVD...")
        self.svd_model = TruncatedSVD(
            n_components=min(50, min(n_users, n_items)-1),
            random_state=42
        )
        item_features_svd = self.svd_model.fit_transform(self.user_item_matrix.T)
        self.item_similarity_matrix = cosine_similarity(item_features_svd)

        # Método 2: NMF para factorización
        print("Calculando factorización NMF...")
        self.nmf_model = NMF(
            n_components=min(30, min(n_users, n_items)-1),
            random_state=42,
            max_iter=200
        )
        self.user_features_nmf = self.nmf_model.fit_transform(self.user_item_matrix)
        self.item_features_nmf = self.nmf_model.components_.T

        # Método 3: Item-based cosine similarity directo
        print("Calculando similitud directa...")
        self.item_similarity_direct = cosine_similarity(self.user_item_matrix.T)

        print("Matrices construidas exitosamente")

    def recommend_method_1_svd(self, target_item, n_recommendations=4):
        """Método 1: Recomendaciones basadas en SVD"""
        start_time = time.time()

        if target_item not in self.item_encoder:
            return [], {'method': 'SVD_Collaborative', 'execution_time': 0}

        target_idx = self.item_encoder[target_item]
        similarities = self.item_similarity_matrix[target_idx]

        # Obtener items más similares (excluyendo el item objetivo)
        similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1]

        recommendations = []
        for idx in similar_indices:
            item_id = self.item_decoder[idx]
            similarity_score = similarities[idx]
            recommendations.append({
                'asin': item_id,
                'similarity_score': similarity_score,
                'method': 'SVD_Collaborative'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'collab_svd', result_asins, execution_time
        )

        return recommendations, metrics

    def recommend_method_2_nmf(self, target_item, n_recommendations=4):
        """Método 2: Recomendaciones basadas en NMF"""
        start_time = time.time()

        if target_item not in self.item_encoder:
            return [], {'method': 'NMF_Collaborative', 'execution_time': 0}

        target_idx = self.item_encoder[target_item]
        target_features = self.item_features_nmf[target_idx]

        # Calcular similitudes con todos los items
        similarities = cosine_similarity([target_features], self.item_features_nmf).flatten()

        # Obtener items más similares (excluyendo el item objetivo)
        similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1]

        recommendations = []
        for idx in similar_indices:
            item_id = self.item_decoder[idx]
            similarity_score = similarities[idx]
            recommendations.append({
                'asin': item_id,
                'similarity_score': similarity_score,
                'method': 'NMF_Collaborative'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'collab_nmf', result_asins, execution_time
        )

        return recommendations, metrics

    def recommend_method_3_direct(self, target_item, n_recommendations=4):
        """Método 3: Similitud directa item-to-item"""
        start_time = time.time()

        if target_item not in self.item_encoder:
            return [], {'method': 'Direct_Collaborative', 'execution_time': 0}

        target_idx = self.item_encoder[target_item]
        similarities = self.item_similarity_direct[target_idx]

        # Obtener items más similares (excluyendo el item objetivo)
        similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1]

        recommendations = []
        for idx in similar_indices:
            item_id = self.item_decoder[idx]
            similarity_score = similarities[idx]
            recommendations.append({
                'asin': item_id,
                'similarity_score': similarity_score,
                'method': 'Direct_Collaborative'
            })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'collab_direct', result_asins, execution_time
        )

        return recommendations, metrics

    def get_available_items(self):
        """Retorna lista de items disponibles para recomendación"""
        return list(self.item_encoder.keys())

# ==================== FUNCIONALIDAD 3: RECOMENDACIÓN BASADA EN CLIENTE (3 MÉTODOS) ====================

class ClientBasedRecommender:
    """Sistema de recomendación basado en productos seleccionados por un cliente"""

    def __init__(self, df_products, embeddings, ratings_dict):
        self.df_products = df_products
        self.embeddings = embeddings
        self.ratings_dict = ratings_dict
        self.setup_methods()

    def setup_methods(self):
        """Configura mapeo ASIN -> índice posicional"""
        self.asin_to_idx = {}

        parent_asins = self.df_products["parent_asin"].values

        for idx, asin in enumerate(parent_asins):
            if pd.notna(asin):
                self.asin_to_idx[asin] = idx

        self.prepare_content_features()

    # Verificación crítica
        assert len(self.embeddings) == len(self.df_products), \
            f"ERROR: embeddings ({len(self.embeddings)}) y dataframe ({len(self.df_products)}) NO coinciden."


    def prepare_content_features(self):
        """Prepara características de contenido para recomendaciones"""
        # Extraer categorías principales
        categories = self.df_products.get('main_category', pd.Series(['Unknown'] * len(self.df_products)))
        self.unique_categories = list(set(categories.fillna('Unknown')))

        # Crear matriz de características categóricas
        self.category_features = np.zeros((len(self.df_products), len(self.unique_categories)))
        for idx, category in enumerate(categories.fillna('Unknown')):
            if category in self.unique_categories:
                cat_idx = self.unique_categories.index(category)
                self.category_features[idx, cat_idx] = 1

    def recommend_method_1_profile_similarity(self, selected_asins, n_recommendations=5):
        """Método 1: Perfil de usuario basado en similitud de embeddings"""
        start_time = time.time()

        if not selected_asins:
            return [], {'method': 'Profile_Similarity', 'execution_time': 0}

        # Obtener embeddings de productos seleccionados
        selected_embeddings = []
        valid_asins = []

        for asin in selected_asins:
            if asin in self.asin_to_idx:
                idx = self.asin_to_idx[asin]
                selected_embeddings.append(self.embeddings[idx])
                valid_asins.append(asin)

        if not selected_embeddings:
            return [], {'method': 'Profile_Similarity', 'execution_time': 0}

        # Crear perfil de usuario como promedio de embeddings
        user_profile = np.mean(selected_embeddings, axis=0)

        # Calcular similitudes con todos los productos
        similarities = cosine_similarity([user_profile], self.embeddings).flatten()

        # Excluir productos ya seleccionados
        excluded_indices = [self.asin_to_idx[asin] for asin in valid_asins if asin in self.asin_to_idx]
        for idx in excluded_indices:
            similarities[idx] = -1

        # Obtener top recomendaciones
        top_indices = np.argsort(similarities)[::-1][:n_recommendations]

        recommendations = []
        for idx in top_indices:
            if similarities[idx] <= 0:
                continue

            row = self.df_products.iloc[idx]
            asin = row.get('parent_asin')
            if asin:
                recommendations.append({
                    'asin': asin,
                    'similarity_score': similarities[idx],
                    'method': 'Profile_Similarity'
                })

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'client_profile', result_asins, execution_time
        )

        return recommendations, metrics

    def recommend_method_2_weighted_categories(self, selected_asins, n_recommendations=5):
        """Método 2: Recomendación basada en categorías ponderadas"""
        start_time = time.time()

        if not selected_asins:
            return [], {'method': 'Weighted_Categories', 'execution_time': 0}

        # Contar categorías en productos seleccionados
        category_weights = defaultdict(float)
        valid_selections = 0

        for asin in selected_asins:
            if asin in self.asin_to_idx:
                idx = self.asin_to_idx[asin]
                row = self.df_products.iloc[idx]
                category = row.get('main_category', 'Unknown')

                # Ponderar por rating del producto
                rating = self.ratings_dict.get(asin, 3.0)
                category_weights[category] += rating / 5.0  # Normalizar rating
                valid_selections += 1

        if not category_weights:
            return [], {'method': 'Weighted_Categories', 'execution_time': 0}

        # Normalizar pesos
        total_weight = sum(category_weights.values())
        for category in category_weights:
            category_weights[category] /= total_weight

        # Calcular scores para todos los productos
        product_scores = []
        excluded_asins = set(selected_asins)

        for idx, row in self.df_products.iterrows():
            asin = row.get('parent_asin')
            if not asin or asin in excluded_asins:
                continue

            category = row.get('main_category', 'Unknown')
            category_score = category_weights.get(category, 0.0)

            # Combinar con rating del producto
            product_rating = self.ratings_dict.get(asin, 0.0)
            final_score = category_score * 0.7 + (product_rating / 5.0) * 0.3

            product_scores.append({
                'asin': asin,
                'similarity_score': final_score,
                'method': 'Weighted_Categories'
            })

        # Ordenar por score y tomar top N
        product_scores.sort(key=lambda x: x['similarity_score'], reverse=True)
        recommendations = product_scores[:n_recommendations]

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'client_categories', result_asins, execution_time
        )

        return recommendations, metrics

    def recommend_method_3_hybrid_approach(self, selected_asins, n_recommendations=5):
        """Método 3: Enfoque híbrido combinando embeddings, categorías y ratings"""
        start_time = time.time()

        if not selected_asins:
            return [], {'method': 'Hybrid_Approach', 'execution_time': 0}

        # Paso 1: Crear perfil de embeddings
        selected_embeddings = []
        selected_categories = []
        selected_ratings = []
        valid_asins = []

        for asin in selected_asins:
            if asin in self.asin_to_idx:
                idx = self.asin_to_idx[asin]
                row = self.df_products.iloc[idx]

                selected_embeddings.append(self.embeddings[idx])
                selected_categories.append(row.get('main_category', 'Unknown'))
                selected_ratings.append(self.ratings_dict.get(asin, 3.0))
                valid_asins.append(asin)

        if not selected_embeddings:
            return [], {'method': 'Hybrid_Approach', 'execution_time': 0}

        # Crear perfil promedio ponderado por rating
        weights = np.array(selected_ratings) / 5.0  # Normalizar ratings
        weights = weights / np.sum(weights)  # Normalizar pesos

        user_profile = np.average(selected_embeddings, axis=0, weights=weights)

        # Paso 2: Calcular preferencias de categoría
        category_preferences = Counter(selected_categories)
        total_selections = len(selected_categories)

        # Paso 3: Evaluar todos los productos candidatos
        candidate_scores = []
        excluded_asins = set(selected_asins)

        for idx, row in self.df_products.iterrows():
            asin = row.get('parent_asin')
            if not asin or asin in excluded_asins:
                continue

            # Score de similitud de embedding
            embedding_similarity = cosine_similarity([user_profile], [self.embeddings[idx]])[0][0]

            # Score de categoría
            category = row.get('main_category', 'Unknown')
            category_score = category_preferences.get(category, 0) / total_selections

            # Score de rating
            product_rating = self.ratings_dict.get(asin, 0.0)
            rating_score = product_rating / 5.0

            # Combinación ponderada
            hybrid_score = (
                embedding_similarity * 0.5 +
                category_score * 0.3 +
                rating_score * 0.2
            )

            candidate_scores.append({
                'asin': asin,
                'similarity_score': hybrid_score,
                'method': 'Hybrid_Approach',
                'embedding_sim': embedding_similarity,
                'category_score': category_score,
                'rating_score': rating_score
            })

        # Ordenar y tomar top N
        candidate_scores.sort(key=lambda x: x['similarity_score'], reverse=True)
        recommendations = candidate_scores[:n_recommendations]

        execution_time = time.time() - start_time

        # Evaluar con métricas
        result_asins = [r['asin'] for r in recommendations]
        metrics = metrics_evaluator.evaluate_recommendations(
            'client_hybrid', result_asins, execution_time
        )

        return recommendations, metrics

# ==================== FUNCIONES DE UTILIDAD ====================
def clean_description(description):
    """Limpia la descripción eliminando corchetes y su contenido"""
    if not description or description == "":
        return "Sin descripción"

    if description.strip().startswith('[') and description.strip().endswith(']'):
        cleaned = description.strip()[1:-1].strip()
    else:
        cleaned = re.sub(r'\[.*?\]', '', description)

    cleaned = re.sub(r'\s+', ' ', cleaned).strip()
    return cleaned if cleaned else "Sin descripción"

def get_best_image_url(row):
    """Extrae la mejor URL de imagen disponible"""
    image_columns = ['image_urls_best', 'image_urls_large', 'image_urls_all']

    for col in image_columns:
        if col in row:
            try:
                images = json.loads(row[col]) if isinstance(row[col], str) else row[col]
                if isinstance(images, list) and images:
                    for img_url in images:
                        if img_url and isinstance(img_url, str) and img_url.startswith("http"):
                            return img_url
            except (json.JSONDecodeError, TypeError, ValueError):
                continue

    return "https://via.placeholder.com/300x300.png?text=No+Image"

def get_product_rating(asin):
    """Obtiene el rating de un producto desde el diccionario de ratings"""
    return ratings_dict.get(asin, 0.0)

def get_product_info_by_asin(asin):
    """Obtiene información de un producto por su ASIN"""
    product_row = df_similars[df_similars['parent_asin'] == asin]
    if len(product_row) == 0:
        return None

    row = product_row.iloc[0]
    return {
        'asin': asin,
        'title': row.get('title', 'Sin título'),
        'description': clean_description(row.get('description', '')),
        'rating': get_product_rating(asin),
        'image_url': get_best_image_url(row),
        'category': row.get('main_category', 'Unknown')
    }

# ==================== INICIALIZACIÓN DE SISTEMAS ====================

# Inicializar sistema de búsqueda por descripción
description_searcher = DescriptionSearcher(df_similars, description_embeddings, model)

# Inicializar sistema colaborativo solo si hay ratings detallados
if HAS_DETAILED_RATINGS:
    print("Inicializando sistema de recomendación colaborativo...")
    collaborative_recommender = CollaborativeRecommender(df_ratings_detailed)
else:
    print("Sistema colaborativo no disponible (requiere ratings detallados)")
    collaborative_recommender = None

# Inicializar sistema basado en cliente
client_recommender = ClientBasedRecommender(df_similars, description_embeddings, ratings_dict)

# ==================== FUNCIONES DE INTERFAZ MEJORADAS ====================

def search_products_enhanced(descripcion_input, method_choice, max_images_per_product=2, target_products=5):
    """Búsqueda mejorada con selección de método"""
    if not descripcion_input.strip():
        return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor escribe algo para buscar...")]

    # Seleccionar método de búsqueda
    if method_choice == "KNN + Embeddings":
        results, metrics = description_searcher.search_method_1_knn(descripcion_input, target_products)
    elif method_choice == "TF-IDF + Cosine":
        results, metrics = description_searcher.search_method_2_tfidf(descripcion_input, target_products)
    elif method_choice == "Clustering + Embeddings":
        results, metrics = description_searcher.search_method_3_cluster(descripcion_input, target_products)
    else:
        # Comparar todos los métodos
        results_knn, metrics_knn = description_searcher.search_method_1_knn(descripcion_input, 2)
        results_tfidf, metrics_tfidf = description_searcher.search_method_2_tfidf(descripcion_input, 2)
        results_cluster, metrics_cluster = description_searcher.search_method_3_cluster(descripcion_input, 2)

        # Combinar resultados
        all_results = results_knn + results_tfidf + results_cluster
        results = sorted(all_results, key=lambda x: x['similarity_score'], reverse=True)[:target_products]

        metrics = {
            'method': 'All_Methods_Combined',
            'knn_time': metrics_knn.get('execution_time', 0),
            'tfidf_time': metrics_tfidf.get('execution_time', 0),
            'cluster_time': metrics_cluster.get('execution_time', 0)
        }

    # Convertir resultados a formato de galería
    gallery_results = []
    for result in results:
        product_info = get_product_info_by_asin(result['asin'])
        if product_info:
            texto = f"🔍 Método: {result['method']}\n"
            texto += f"📦 {product_info['title']}\n"
            texto += f"⭐ Rating: {product_info['rating']:.2f}\n"
            texto += f"🎯 Similitud: {result['similarity_score']:.3f}\n"
            texto += f"📂 Categoría: {product_info['category']}\n\n"
            texto += f"📝 {product_info['description'][:200]}{'...' if len(product_info['description']) > 200 else ''}"

            gallery_results.append((product_info['image_url'], texto))

    return gallery_results

def get_collaborative_recommendations_enhanced(selected_product_asin, method_choice):
    """Recomendaciones colaborativas mejoradas con selección de método"""
    if not collaborative_recommender:
        return [("https://via.placeholder.com/300.png?text=No+Disponible", "Sistema colaborativo no disponible")]

    if not selected_product_asin:
        return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor selecciona un producto...")]

    # Seleccionar método colaborativo
    if method_choice == "SVD":
        recommendations, metrics = collaborative_recommender.recommend_method_1_svd(selected_product_asin)
    elif method_choice == "NMF":
        recommendations, metrics = collaborative_recommender.recommend_method_2_nmf(selected_product_asin)
    elif method_choice == "Direct Similarity":
        recommendations, metrics = collaborative_recommender.recommend_method_3_direct(selected_product_asin)
    else:
        # Comparar todos los métodos
        rec_svd, met_svd = collaborative_recommender.recommend_method_1_svd(selected_product_asin, 2)
        rec_nmf, met_nmf = collaborative_recommender.recommend_method_2_nmf(selected_product_asin, 2)
        rec_direct, met_direct = collaborative_recommender.recommend_method_3_direct(selected_product_asin, 1)

        recommendations = rec_svd + rec_nmf + rec_direct
        metrics = {'method': 'All_Collaborative_Methods'}

    if not recommendations:
        return [("https://via.placeholder.com/300.png?text=Sin+Recomendaciones", "No se encontraron recomendaciones para este producto.")]

    # Convertir a formato de galería
    gallery_results = []
    for rec in recommendations:
        product_info = get_product_info_by_asin(rec['asin'])
        if product_info:
            texto = f"🤝 Método: {rec['method']}\n"
            texto += f"📦 {product_info['title']}\n"
            texto += f"⭐ Rating: {product_info['rating']:.2f}\n"
            texto += f"🎯 Similitud: {rec['similarity_score']:.3f}\n"
            texto += f"📂 Categoría: {product_info['category']}\n\n"
            texto += f"📝 {product_info['description'][:200]}{'...' if len(product_info['description']) > 200 else ''}"

            gallery_results.append((product_info['image_url'], texto))

    return gallery_results

def get_client_recommendations(selected_asins_text, method_choice, n_recommendations=5):
    """Recomendaciones basadas en cliente con selección de método"""
    if not selected_asins_text.strip():
        return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor ingresa ASINs de productos...")]

    # Parsear ASINs (separados por comas, espacios o nuevas líneas)
    selected_asins = []
    for asin in re.split(r'[,\s\n]+', selected_asins_text.strip()):
        asin = asin.strip()
        if asin:
            selected_asins.append(asin)

    if not selected_asins:
        return [("https://via.placeholder.com/300.png?text=Error", "No se pudieron parsear los ASINs")]

    # Seleccionar método de recomendación basada en cliente
    if method_choice == "Profile Similarity":
        recommendations, metrics = client_recommender.recommend_method_1_profile_similarity(selected_asins, n_recommendations)
    elif method_choice == "Weighted Categories":
        recommendations, metrics = client_recommender.recommend_method_2_weighted_categories(selected_asins, n_recommendations)
    elif method_choice == "Hybrid Approach":
        recommendations, metrics = client_recommender.recommend_method_3_hybrid_approach(selected_asins, n_recommendations)
    else:
        # Comparar todos los métodos
        rec_profile, met_profile = client_recommender.recommend_method_1_profile_similarity(selected_asins, 2)
        rec_categories, met_categories = client_recommender.recommend_method_2_weighted_categories(selected_asins, 2)
        rec_hybrid, met_hybrid = client_recommender.recommend_method_3_hybrid_approach(selected_asins, 1)

        recommendations = rec_profile + rec_categories + rec_hybrid
        metrics = {'method': 'All_Client_Methods'}

    if not recommendations:
        return [("https://via.placeholder.com/300.png?text=Sin+Recomendaciones", "No se encontraron recomendaciones para los productos seleccionados.")]

    # Convertir a formato de galería
    gallery_results = []
    for rec in recommendations:
        product_info = get_product_info_by_asin(rec['asin'])
        if product_info:
            texto = f"👤 Método: {rec['method']}\n"
            texto += f"📦 {product_info['title']}\n"
            texto += f"⭐ Rating: {product_info['rating']:.2f}\n"
            texto += f"🎯 Score: {rec['similarity_score']:.3f}\n"
            texto += f"📂 Categoría: {product_info['category']}\n\n"

            # Información adicional para método híbrido
            if 'embedding_sim' in rec:
                texto += f"🔗 Sim. Embedding: {rec['embedding_sim']:.3f}\n"
                texto += f"📂 Score Categoría: {rec['category_score']:.3f}\n"
                texto += f"⭐ Score Rating: {rec['rating_score']:.3f}\n\n"

            texto += f"📝 {product_info['description'][:150]}{'...' if len(product_info['description']) > 150 else ''}"

            gallery_results.append((product_info['image_url'], texto))

    return gallery_results

def get_product_options():
    """Obtiene lista de productos disponibles para el dropdown"""
    if not collaborative_recommender:
        return [("Sistema no disponible", "")]

    available_asins = collaborative_recommender.get_available_items()
    options = []

    for asin in available_asins[:100]:  # Limitar para performance
        product_info = get_product_info_by_asin(asin)
        if product_info and product_info['rating'] > 0:
            label = f"{product_info['title'][:50]}... (Rating: {product_info['rating']:.1f})"
            options.append((label, asin))

    return options

def get_metrics_report():
    """Genera reporte de métricas para mostrar en la interfaz"""
    return metrics_evaluator.get_comparison_report()

# ==================== INTERFAZ GRADIO MEJORADA ====================
def create_enhanced_interface():
    """Crea la interfaz mejorada con todas las funcionalidades y métricas"""

    with gr.Blocks(title="🚀 Advanced Product Recommendaation System", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🚀 Advanced Product Recommendaation System

        **Funcionalidades disponibles:**
        - 🔍 **Búsqueda por Descripción** (3 métodos: KNN+Embeddings, TF-IDF+Cosine, Clustering+Embeddings)
        - 🤝 **Recomendación Colaborativa** (3 métodos: SVD, NMF, Direct Similarity)
        - 👤 **Recomendación Basada en Cliente** (3 métodos: Profile Similarity, Weighted Categories, Hybrid Approach)
        - 📊 **Métricas y Comparación** en tiempo real
        """)

        with gr.Tabs():
            # TAB 1: Búsqueda por descripción mejorada
            with gr.TabItem("🔍 Búsqueda por Descripción"):
                gr.Markdown("### Describe el producto que buscas en inglés y selecciona el método de búsqueda")

                with gr.Row():
                    with gr.Column(scale=1):
                        descripcion_input = gr.Textbox(
                            label="Describe your ideal product",
                            placeholder="exp: Handmade shungite bead bracelet, Silver necklace, etc."
                        )
                        search_method = gr.Dropdown(
                            choices=["KNN + Embeddings", "TF-IDF + Cosine", "Clustering + Embeddings", "Comparar Todos"],
                            value="KNN + Embeddings",
                            label="Método de búsqueda"
                        )
                        max_images = gr.Slider(
                            minimum=1, maximum=3, value=2, step=1,
                            label="Máximo de imágenes por producto"
                        )
                        num_products = gr.Slider(
                            minimum=1, maximum=10, value=5, step=1,
                            label="Número de productos a mostrar"
                        )
                        search_btn = gr.Button("🔍 Buscar Productos", variant="primary", size="lg")

                    with gr.Column(scale=2):
                        search_gallery = gr.Gallery(
                            label="Productos Encontrados",
                            columns=3,
                            rows=2,
                            height="auto"
                        )

            # TAB 2: Recomendaciones colaborativas mejoradas
            if collaborative_recommender:
                with gr.TabItem("🤝 Recomendaciones Colaborativas"):
                    gr.Markdown("### Selecciona un producto base y el método de recomendación colaborativa")

                    with gr.Row():
                        with gr.Column(scale=1):
                            product_dropdown = gr.Dropdown(
                                choices=get_product_options(),
                                label="Selecciona un producto base",
                                value=None
                            )
                            collab_method = gr.Dropdown(
                                choices=["SVD", "NMF", "Direct Similarity", "Comparar Todos"],
                                value="SVD",
                                label="Método colaborativo"
                            )
                            recommend_btn = gr.Button("🤝 Obtener Recomendaciones", variant="primary", size="lg")
                            refresh_products_btn = gr.Button("🔄 Actualizar Lista")

                        with gr.Column(scale=2):
                            recommendations_gallery = gr.Gallery(
                                label="Recomendaciones Colaborativas",
                                columns=2,
                                rows=2,
                                height="auto"
                            )

            # TAB 3: Recomendaciones basadas en cliente (NUEVA FUNCIONALIDAD)
            with gr.TabItem("👤 Recomendaciones Basadas en Cliente"):
                gr.Markdown("""
                ### Ingresa los ASINs de productos que un cliente ha seleccionado
                **Formato:** Separa los ASINs con comas, espacios o nuevas líneas
                **Ejemplo 1:** B07NTK7T5P, B0751M85FV, B01HYNE114, B0BKBJT5MM.
                **Ejemplo 2:** B01BAN3CBE, B0754TWHPT, B079KM6HDM, B097B8WH61.
                **Ejemplo 3:** B0B8WK62Z3, B01BYCH44W, B0BGNQ3CLH, B084L4PF4M.
                            
                """)

                with gr.Row():
                    with gr.Column(scale=1):
                        client_asins_input = gr.Textbox(
                            label="ASINs de productos seleccionados por el cliente",
                            placeholder="Insert here the product´s ID´s to get other products you might enjoy!",
                            lines=3
                        )
                        client_method = gr.Dropdown(
                            choices=["Profile Similarity", "Weighted Categories", "Hybrid Approach", "Comparar Todos"],
                            value="Hybrid Approach",
                            label="Método de recomendación"
                        )
                        client_num_recs = gr.Slider(
                            minimum=1, maximum=10, value=5, step=1,
                            label="Número de recomendaciones"
                        )
                        client_recommend_btn = gr.Button("👤 Generar Recomendaciones", variant="primary", size="lg")

                        with gr.Accordion("ℹ️ Información de Métodos", open=False):
                            gr.Markdown("""
                            **Profile Similarity:** Crea un perfil promedio basado en los embeddings de los productos seleccionados

                            **Weighted Categories:** Recomienda basándose en las categorías más frecuentes, ponderadas por rating

                            **Hybrid Approach:** Combina embeddings, categorías y ratings con pesos optimizados
                            """)

                    with gr.Column(scale=2):
                        client_gallery = gr.Gallery(
                            label="Recomendaciones para el Cliente",
                            columns=3,
                            rows=2,
                            height="auto"
                        )

            # TAB 4: Métricas y comparación
            with gr.TabItem("📊 Métricas y Comparación"):
                gr.Markdown("### Análisis de rendimiento y comparación de métodos")

                with gr.Row():
                    with gr.Column():
                        metrics_btn = gr.Button("📊 Actualizar Métricas", variant="secondary")
                        clear_metrics_btn = gr.Button("🗑️ Limpiar Historial")

                metrics_output = gr.Markdown("Ejecuta algunas recomendaciones para ver las métricas...")

        # Estadísticas del sistema
        with gr.Accordion("📈 Estadísticas del Sistema", open=False):
            collab_stats = ""
            if collaborative_recommender:
                collab_stats = f"""
                - 🤝 Productos disponibles para recomendación colaborativa: {len(collaborative_recommender.get_available_items()):,}
                - 🧮 Dimensiones de matriz SVD: {collaborative_recommender.item_similarity_matrix.shape}
                """

            stats_text = f"""
            **Estadísticas del Sistema Completo:**
            - 📊 Total de productos: {len(df_similars):,}
            - ⭐ Productos con ratings: {len(ratings_dict):,}
            - 🔍 Embeddings precalculados: {len(description_embeddings):,}
            - ✅ Consistencia verificada: {len(description_embeddings) == len(df_similars)}
            - 🎯 Métodos de búsqueda: 3 implementados
            - 🤝 Métodos colaborativos: {"3 implementados" if collaborative_recommender else "No disponible"}
            - 👤 Métodos basados en cliente: 3 implementados
            {collab_stats}
            """
            gr.Markdown(stats_text)

        # ==================== EVENTOS ====================

        # Búsqueda por descripción
        search_btn.click(
            fn=search_products_enhanced,
            inputs=[descripcion_input, search_method, max_images, num_products],
            outputs=search_gallery
        )

        # Recomendaciones colaborativas (solo si está disponible)
        if collaborative_recommender:
            recommend_btn.click(
                fn=get_collaborative_recommendations_enhanced,
                inputs=[product_dropdown, collab_method],
                outputs=recommendations_gallery
            )

            refresh_products_btn.click(
                fn=lambda: gr.Dropdown(choices=get_product_options()),
                outputs=product_dropdown
            )

        # Recomendaciones basadas en cliente
        client_recommend_btn.click(
            fn=get_client_recommendations,
            inputs=[client_asins_input, client_method, client_num_recs],
            outputs=client_gallery
        )

        # Métricas
        metrics_btn.click(
            fn=get_metrics_report,
            outputs=metrics_output
        )

        def clear_metrics():
            global metrics_evaluator
            metrics_evaluator = RecommendationMetrics()
            return "Historial de métricas limpiado."

        clear_metrics_btn.click(
            fn=clear_metrics,
            outputs=metrics_output
        )

    return demo

# ==================== LANZAMIENTO ====================
if __name__ == "__main__":
    print("🚀 Iniciando sistema avanzado de recomendación...")

    # Verificar configuración
    print(f"✅ DataFrame: {len(df_similars):,} productos")
    print(f"✅ Embeddings: {description_embeddings.shape}")
    print(f"✅ Consistencia: {len(description_embeddings) == len(df_similars)}")
    print(f"✅ Búsqueda por descripción: 3 métodos disponibles")

    if collaborative_recommender:
        print(f"✅ Sistema colaborativo: 3 métodos con {len(collaborative_recommender.get_available_items()):,} productos")
    else:
        print("⚠️ Sistema colaborativo no disponible")

    print(f"✅ Sistema basado en cliente: 3 métodos disponibles")
    print(f"✅ Sistema de métricas: Inicializado")

    # Crear y lanzar interfaz
    demo = create_enhanced_interface()
    demo.launch(
        share=False,
        debug=False,
        show_error=True,
        server_name="0.0.0.0",
        server_port=7860
    )