"""
COMP 341 Homework 2: Movie Critics

Find critics whose ratings best predict audience scores using data cleaning,
imputation, PCA, and correlation analysis.

Functions to implement:
- load_critic_data: Load critic reviews CSV
- load_movie_data: Load movies CSV
- remove_unnamed_critics: Filter out critics with no name
- filter_critics_by_review_count: Keep critics with >= threshold scored movies
- clean_review_scores: Normalize all scores to 0-100 scale
- prepare_critic_movie_matrix: Create pivot table of critics x movies
- impute_missing_zeros: Fill NaN with 0
- impute_missing_mean: Fill NaN with column mean
- impute_missing_knn: Fill NaN using KNN imputation
- calculate_critic_correlation: Pearson correlation with audience score
- get_top_correlated_critics: Top n critics by correlation
- run_pca: Principal Component Analysis
"""

import pandas as pd
import numpy as np
from pathlib import Path
from typing import Union, List, Tuple
from sklearn.impute import KNNImputer
from sklearn.decomposition import PCA


# =============================================================================
# Data Loading Functions
# =============================================================================

def load_critic_data(data_dir: Union[str, Path]) -> pd.DataFrame:
    """Load rotten_tomatoes_critic_reviews.csv.

    Args:
        data_dir: Path to directory containing the CSV file

    Returns:
        DataFrame with columns: rotten_tomatoes_link, critic_name, top_critic,
        publisher_name, review_type, review_score, review_date, review_content
    """
    # TODO: Implement this function
    # Hint: Use pd.read_csv()
    # Hint: File is ~226MB with 1.1M rows
    pass


def load_movie_data(data_dir: Union[str, Path]) -> pd.DataFrame:
    """Load rotten_tomatoes_movies.csv.

    Args:
        data_dir: Path to directory containing the CSV file

    Returns:
        DataFrame with movie information including audience_rating
    """
    # TODO: Implement this function
    pass


# =============================================================================
# Data Cleaning Functions
# =============================================================================

def remove_unnamed_critics(df: pd.DataFrame) -> pd.DataFrame:
    """Remove critics with no name (empty string or NaN critic_name).

    Args:
        df: Critic reviews DataFrame

    Returns:
        DataFrame with unnamed critics removed
    """
    # TODO: Implement this function
    # Hint: Check for both NaN and empty strings
    pass


def filter_critics_by_review_count(
    df: pd.DataFrame,
    threshold: int = 500
) -> pd.DataFrame:
    """Filter to keep only critics who have scored at least `threshold` movies.

    Important: Count movies with actual scores (non-NaN review_score),
    not just total reviews.

    Args:
        df: Critic reviews DataFrame
        threshold: Minimum number of scored movies

    Returns:
        DataFrame containing only reviews from critics who meet the threshold
    """
    # TODO: Implement this function
    # Hint: Group by critic_name, count non-null review_score
    # Hint: Filter to critics meeting threshold, then filter original df
    pass


def clean_review_scores(df: pd.DataFrame) -> pd.DataFrame:
    """Normalize all review_score values to 0-100 scale.

    Must handle these formats:
    - Fractions: "3/5" -> 60, "3/4" -> 75, "87/100" -> 87, "4/10" -> 40
    - Letter grades: "A" -> 95, "A-" -> 92, "B+" -> 88, "B" -> 85,
                     "B-" -> 82, "C+" -> 78, "C" -> 75, "C-" -> 72,
                     "D+" -> 68, "D" -> 65, "D-" -> 62, "F" -> 50
    - Direct numbers: Already in 0-100 range, keep as-is
    - Empty/NaN: Preserve as NaN (do not convert to 0)

    Edge cases to handle:
    - Fractions where numerator > denominator (e.g., "92/10"):
      These are likely already on a 0-100 scale, so use numerator directly
      (92/10 -> 92, not 9.2*100=920)
    - Values > 100: cap at 100 (likely data entry errors)

    Args:
        df: Critic reviews DataFrame with review_score column

    Returns:
        DataFrame with normalized review_score column (float, 0-100 or NaN)
    """
    # TODO: Implement this function
    # Hint: Create a helper function to convert a single score
    # Hint: Use df['review_score'].apply() with the helper
    # Hint: Handle fractions by splitting on '/' and dividing
    # Hint: Use a dictionary for letter grade mappings
    # Hint: Be careful with edge cases like "92/10" -> should be 92, not 920
    pass


# =============================================================================
# Matrix Preparation and Imputation Functions
# =============================================================================

def prepare_critic_movie_matrix(
    critic_df: pd.DataFrame,
    movie_df: pd.DataFrame
) -> pd.DataFrame:
    """Create pivot table: movies (rows) x critics (columns) with audience_score.

    Args:
        critic_df: Cleaned critic reviews DataFrame (with normalized scores)
        movie_df: Movies DataFrame with audience_rating

    Returns:
        DataFrame where:
        - Each row is a movie (indexed by rotten_tomatoes_link)
        - Each column is a critic (their normalized score for that movie)
        - Last column is 'audience_score' from movie_df
        - Missing values are NaN (critic didn't review that movie)
    """
    # TODO: Implement this function
    # Hint: Use pd.pivot_table() with critic_df
    # Hint: Join with movie_df on rotten_tomatoes_link to get audience_rating
    # Hint: Rename audience_rating to audience_score for clarity
    pass


def impute_missing_zeros(df: pd.DataFrame) -> pd.DataFrame:
    """Fill missing values with 0.

    Args:
        df: Critic-movie matrix with NaN values

    Returns:
        DataFrame with NaN replaced by 0
    """
    # TODO: Implement this function
    # Hint: Use df.fillna(0)
    pass


def impute_missing_mean(
    df: pd.DataFrame,
    exclude_cols: List[str] = None
) -> pd.DataFrame:
    """Fill missing values with column mean (per critic).

    Args:
        df: Critic-movie matrix with NaN values
        exclude_cols: Columns to exclude from imputation (e.g., ['audience_score'])

    Returns:
        DataFrame with NaN replaced by column means
    """
    # TODO: Implement this function
    # Hint: For each column (except excluded), fill NaN with that column's mean
    # Hint: df[col].fillna(df[col].mean())
    if exclude_cols is None:
        exclude_cols = ['audience_score']
    pass


def impute_missing_knn(
    df: pd.DataFrame,
    k: int = 5,
    exclude_cols: List[str] = None
) -> pd.DataFrame:
    """Fill missing values using KNN imputation.

    Uses k nearest neighbors to estimate missing values based on
    similar movies' scores.

    Args:
        df: Critic-movie matrix with NaN values
        k: Number of neighbors for KNN

    Returns:
        DataFrame with NaN replaced by KNN-imputed values
    """
    # TODO: Implement this function
    # Hint: Use sklearn.impute.KNNImputer
    # Hint: Exclude audience_score from imputation, add back after
    # Hint: KNNImputer returns numpy array, convert back to DataFrame
    if exclude_cols is None:
        exclude_cols = ['audience_score']
    pass


# =============================================================================
# Analysis Functions
# =============================================================================

def calculate_critic_correlation(
    df: pd.DataFrame,
    target_col: str = 'audience_score'
) -> pd.Series:
    """Calculate Pearson correlation between each critic and the target.

    Args:
        df: Imputed critic-movie matrix (no NaN values)
        target_col: Column to correlate against (default: audience_score)

    Returns:
        Series with critic names as index and correlation coefficients as values
    """
    # TODO: Implement this function
    # Hint: Use df.corrwith() or calculate manually with df.corr()
    # Hint: Exclude target_col from the result
    pass


def get_top_correlated_critics(
    correlations: pd.Series,
    n: int = 5
) -> List[str]:
    """Return the top n critic names most positively correlated with audience score.

    Args:
 
... (truncated 2103 chars)

#!/usr/bin/env python3
"""Quick analysis script to get data for written questions."""

import pandas as pd
import numpy as np
import sys
from pathlib import Path

# Add current directory to path
sys.path.insert(0, str(Path(__file__).parent))

from solution import (
    load_critic_data, load_movie_data, remove_unnamed_critics,
    filter_critics_by_review_count, clean_review_scores,
    prepare_critic_movie_matrix, impute_missing_zeros, impute_missing_mean,
    impute_missing_knn, calculate_critic_correlation, get_top_correlated_critics,
    calculate_critic_bias
)

# Use the Docker mount path for data
DATA_DIR = Path('/data/hw2')

print("Loading data...")
critic_df = load_critic_data(DATA_DIR)
movie_df = load_movie_data(DATA_DIR)

print(f"Loaded {len(critic_df)} critic reviews and {len(movie_df)} movies")

# Part 0: Data exploration
print("\n=== PART 0: DATA EXPLORATION ===")
critic_df_clean = remove_unnamed_critics(critic_df)
num_unique_critics = critic_df_clean['critic_name'].nunique()
print(f"Unique critics: {num_unique_critics}")

# Part 1: Reviewer bias
print("\n=== PART 1: REVIEWER BIAS ===")
bias_df = calculate_critic_bias(critic_df_clean)
avg_fresh_pct = bias_df['fresh_pct'].mean()
print(f"Average Fresh%: {avg_fresh_pct:.1f}%")
print(f"Average Rotten%: {100 - avg_fresh_pct:.1f}%")

# Part 3: Filtering and imputation
print("\n=== PART 3: FILTERING AND IMPUTATION ===")
critic_df_clean = remove_unnamed_critics(critic_df)
critic_df_clean = clean_review_scores(critic_df_clean)
critic_df_filtered = filter_critics_by_review_count(critic_df_clean, threshold=500)

print(f"Critics with 500+ reviews: {critic_df_filtered['critic_name'].nunique()}")

# Create matrix
matrix = prepare_critic_movie_matrix(critic_df_filtered, movie_df)
print(f"Matrix shape: {matrix.shape}")

# Imputation and correlation
print("\nZERO IMPUTATION:")
matrix_zeros = impute_missing_zeros(matrix)
corr_zeros = calculate_critic_correlation(matrix_zeros)
top_5_zeros = get_top_correlated_critics(corr_zeros, n=5)
print("Top 5:", top_5_zeros)
for i, critic in enumerate(top_5_zeros, 1):
    print(f"  {i}. {critic} (r={corr_zeros[critic]:.4f})")

print("\nMEAN IMPUTATION:")
matrix_mean = impute_missing_mean(matrix)
corr_mean = calculate_critic_correlation(matrix_mean)
top_5_mean = get_top_correlated_critics(corr_mean, n=5)
print("Top 5:", top_5_mean)
for i, critic in enumerate(top_5_mean, 1):
    print(f"  {i}. {critic} (r={corr_mean[critic]:.4f})")

print("\nKNN IMPUTATION:")
matrix_knn = impute_missing_knn(matrix, k=5)
corr_knn = calculate_critic_correlation(matrix_knn)
top_5_knn = get_top_correlated_critics(corr_knn, n=5)
print("Top 5:", top_5_knn)
for i, critic in enumerate(top_5_knn, 1):
    print(f"  {i}. {critic} (r={corr_knn[critic]:.4f})")

# Find common critics across methods
common_critics = set(top_5_zeros) & set(top_5_mean) & set(top_5_knn)
print(f"\nCritics in all top 5 lists: {common_critics}")

# Recommendations
all_top_critics = set(top_5_zeros) | set(top_5_mean) | set(top_5_knn)
# Score by number of appearances in top 5 and average correlation
critic_scores = {}
for critic in all_top_critics:
    score = 0
    count = 0
    if critic in top_5_zeros:
        score += corr_zeros[critic]
        count += 1
    if critic in top_5_mean:
        score += corr_mean[critic]
        count += 1
    if critic in top_5_knn:
        score += corr_knn[critic]
        count += 1
    critic_scores[critic] = (score / count if count > 0 else 0, count)

# Get top 3 by average correlation across methods
top_3_recommendations = sorted(critic_scores.items(), key=lambda x: (x[1][1], x[1][0]), reverse=True)[:3]
print("\n=== RECOMMENDATIONS ===")
for i, (critic, (avg_corr, appearances)) in enumerate(top_3_recommendations, 1):
    print(f"{i}. {critic} (avg_r={avg_corr:.4f}, appears in {appearances}/3 methods)")