from typing import Optional, Dict
import pandas as pd
import matplotlib.pyplot as plt
import logging
from data_manager import data_manager

logger = logging.getLogger(__name__)

def filter_leaderboard(
    family: Optional[str] = None,
    quantization_level: Optional[str] = None
) -> pd.DataFrame:
    """Filter leaderboard data based on criteria."""
    try:
        df = data_manager.leaderboard_data.copy()
        
        if df.empty:
            logger.warning("Leaderboard data is empty, returning empty DataFrame")
            return pd.DataFrame()
        
        if family:
            df = df[df["family"] == family]
        if quantization_level:
            df = df[df["quantization_level"] == quantization_level]
        
        return df.sort_values("score", ascending=False)
    except Exception as e:
        logger.error(f"Error filtering leaderboard: {e}")
        return pd.DataFrame()

def search_responses(query: str, model: str) -> pd.DataFrame:
    """Search model responses based on query."""
    try:
        if not query or not model:
            return pd.DataFrame()
        
        df = data_manager.responses_data
        
        if df.empty:
            logger.warning("Responses data is empty, returning empty DataFrame")
            return pd.DataFrame()
        
        # Check if model column exists
        model_column = f"{model}_cevap"
        if model_column not in df.columns:
            logger.warning(f"Model column '{model_column}' not found in responses data")
            return pd.DataFrame({"error": [f"Model '{model}' responses not found"]})
        
        filtered = df[
            df["bolum"].str.contains(query, case=False, na=False)
        ]
        
        selected_columns = ["bolum", "soru", "cevap", model_column]
        return filtered[selected_columns].dropna()
    except Exception as e:
        logger.error(f"Error searching responses: {e}")
        return pd.DataFrame({"error": [f"Error: {str(e)}"]})

def plot_section_results() -> plt.Figure:
    """Generate section results plot."""
    try:
        df = data_manager.section_results_data
        
        if df.empty:
            logger.warning("Section results data is empty, returning empty plot")
            fig, ax = plt.subplots(figsize=(12, 6))
            ax.text(0.5, 0.5, "No data available", ha='center', va='center', fontsize=14)
            ax.set_title("Section-Wise Performance", pad=20)
            plt.tight_layout()
            return fig
        
        fig, ax = plt.subplots(figsize=(12, 6))
        avg_scores = df.mean(numeric_only=True)
        
        bars = avg_scores.plot(kind="bar", ax=ax)
        
        # Customize plot
        ax.set_title("Average Section-Wise Performance", pad=20)
        ax.set_ylabel("Accuracy (%)")
        ax.set_xlabel("Sections")
        plt.xticks(rotation=45, ha='right')
        plt.tight_layout()
        
        # Add value labels
        for i, v in enumerate(avg_scores):
            ax.text(i, v, f'{v:.1f}%', ha='center', va='bottom')
        
        return fig
    except Exception as e:
        logger.error(f"Error plotting section results: {e}")
        fig, ax = plt.subplots(figsize=(12, 6))
        ax.text(0.5, 0.5, f"Error generating plot: {str(e)}", ha='center', va='center', fontsize=12)
        plt.tight_layout()
        return fig

def validate_model_submission(
    model_name: str,
    base_model: str,
    revision: str,
    precision: str,
    weight_type: str,
    model_type: str
) -> tuple[bool, str]:
    """Validate model submission parameters."""
    try:
        if not all([model_name, base_model]):
            return False, "Model name and base model are required."
        
        # Check if leaderboard data is available
        if not data_manager.leaderboard_data.empty:
            if model_name in data_manager.leaderboard_data["model"].values:
                return False, "Model name already exists."
        
        return True, "Validation successful"
    except Exception as e:
        logger.error(f"Error validating model submission: {e}")
        return False, f"Validation error: {str(e)}"