import torch, json, os, sys
import numpy as np
from collections import defaultdict
import warnings
warnings.filterwarnings('ignore')

os.chdir('/weka/scratch/melhila1/karan/EMMA2_text_conditioning_contextual')

MODELS = [
    ('TSDL', 'experiments/TSDL_old_mixtures/eval_outputs_test_3k/results.eval.pth'),
    ('no_TSDL', 'experiments/no_TSDL_old_mixtures/eval_outputs_test_3k/results.eval.pth'),
    ('combined', 'experiments/combined_v1/eval_outputs_test_3k/results.eval.pth'),
    ('freq_weighted', 'experiments/frequencyweighted_v1/eval_outputs_test_3k/results.eval.pth'),
    ('multiscale', 'experiments/multiscale_v1/eval_outputs_test_3k/results.eval.pth'),
    ('comb_learned', 'experiments/combined_learned_v1/eval_outputs_test_3k/results.eval.pth'),
    ('fw_learned', 'experiments/freq_weighted_learned_v1/eval_outputs_test_3k/results.eval.pth'),
]

# Per-sample metrics (lists in each batch) — can be broken down by cmd/distractor
ALL_METRICS = [
    'scale_invariant_signal_noise_ratio',
    'signal_noise_ratio',
    'si_snr',
    'td_loss',
    'delta_ILD',
    'delta_ITD',
    'delta_ITD_gcc',
    'spatial_clap_score',
    'msclap_score',
]
METRIC_NAMES = {
    'scale_invariant_signal_noise_ratio': 'SI-SNRi(dB)',   # improvement: si_snr(output,target) - si_snr(input,target)
    'signal_noise_ratio': 'SNRi(dB)',                      # improvement: snr(output,target) - snr(input,target)
    'si_snr': 'SI-SNR(dB)',                                # absolute: si_snr(output, target)
    'td_loss': 'TD Loss',
    'delta_ILD': 'd_ILD',
    'delta_ITD': 'd_ITD(xcorr)',
    'delta_ITD_gcc': 'd_ITD(gcc)',
    'spatial_clap_score': 'CLAP(spat)',
    'msclap_score': 'CLAP(ms)',
}
# Lower is better for these
LOWER_BETTER = {'td_loss', 'delta_ILD', 'delta_ITD', 'delta_ITD_gcc'}

COL_W = 20

def load_results(pth_path):
    batches = torch.load(pth_path, map_location='cpu', weights_only=False)
    all_metrics = defaultdict(list)
    all_cmd_types = []
    all_dist_counts = []
    available_metrics = set(batches[0].keys()) - {'metadata'}
    for batch in batches:
        n = len(batch['signal_noise_ratio'])
        for m in ALL_METRICS:
            if m in batch:
                all_metrics[m].extend(batch[m])
        for i in range(n):
            meta = batch['metadata'][i]
            cmd = meta.get('command_variant', {}).get('command_type', 'unknown')
            dist_count = meta.get('distractor_count', 0)
            all_cmd_types.append(cmd)
            all_dist_counts.append(dist_count)
    return {m: np.array(v) for m, v in all_metrics.items()}, all_cmd_types, all_dist_counts, available_metrics

model_data = {}
model_available = {}
for name, path in MODELS:
    metrics, cmd_types, dist_counts, avail = load_results(path)
    model_data[name] = (metrics, cmd_types, dist_counts)
    model_available[name] = avail
    print(f"Loaded {name}: {len(cmd_types)} samples, metrics: {sorted(avail)}", flush=True)

n_samples = len(model_data['TSDL'][1])
model_names = [x[0] for x in MODELS]

def print_table(title, count, mask_fn):
    print(f"\n{'='*170}", flush=True)
    print(f"{title}  ({count} samples)", flush=True)
    print('='*170, flush=True)

    header = f"{'Model':<16}"
    for m in ALL_METRICS:
        header += f"{METRIC_NAMES[m]:>{COL_W}}"
    print(header, flush=True)
    print("-"*len(header), flush=True)

    # Find best value per metric (only among models that have it)
    best = {}
    for m in ALL_METRICS:
        vals = []
        for nm in model_names:
            mets = model_data[nm][0]
            if m not in mets:
                continue
            cl, dl = model_data[nm][1], model_data[nm][2]
            mask = mask_fn(cl, dl)
            vals.append(float(np.mean(mets[m][mask])))
        if not vals:
            continue
        if m in LOWER_BETTER:
            best[m] = min(vals)
        else:
            best[m] = max(vals)

    for nm in model_names:
        mets, cl, dl = model_data[nm]
        mask = mask_fn(cl, dl)
        row = f"{nm:<16}"
        for m in ALL_METRICS:
            if m not in mets:
                row += f"{'N/A':>{COL_W}}"
            else:
                vals = mets[m][mask]
                mean_val = float(np.mean(vals))
                std_val = float(np.std(vals))
                is_best = m in best and abs(mean_val - best[m]) < 1e-6
                marker = "*" if is_best else " "
                cell = f"{mean_val:.2f}\u00b1{std_val:.2f}"
                row += f"{cell:>{COL_W-1}}{marker}"
        print(row, flush=True)

print(f"\nTotal samples per model: {n_samples}", flush=True)

# TABLE 1
print_table("TABLE 1: GLOBAL PERFORMANCE", n_samples,
            lambda c, d: np.ones(len(c), dtype=bool))

# TABLE 2: BY COMMAND TYPE
cmd_types_set = sorted(set(model_data['TSDL'][1]))
for i, cmd in enumerate(cmd_types_set):
    n_cmd = sum(1 for c in model_data['TSDL'][1] if c == cmd)
    print_table(f"TABLE 2.{i+1}: COMMAND TYPE = '{cmd}'", n_cmd,
                lambda c, d, _cmd=cmd: np.array([x == _cmd for x in c]))

# TABLE 3: BY DISTRACTOR COUNT
dist_set = sorted(set(model_data['TSDL'][2]))
for i, dc in enumerate(dist_set):
    n_dc = sum(1 for d in model_data['TSDL'][2] if d == dc)
    print_table(f"TABLE 3.{i+1}: DISTRACTOR COUNT = {dc}", n_dc,
                lambda c, d, _dc=dc: np.array([x == _dc for x in d]))

print(f"\n{'='*170}", flush=True)
print("LEGEND: * = best model for that metric", flush=True)
print("  SI-SNRi(dB) = SI-SNR improvement over input mixture: si_snr(output,target) - si_snr(input,target)", flush=True)
print("  SNRi(dB)    = SNR improvement over input mixture:    snr(output,target) - snr(input,target)", flush=True)
print("  SI-SNR(dB)  = Absolute SI-SNR of output:             si_snr(output, target)", flush=True)
print("  Higher=better: SI-SNRi(dB), SNRi(dB), SI-SNR(dB), CLAP(spat), CLAP(ms)", flush=True)
print("  d_ITD(xcorr)= ITD error via cross-correlation (microseconds)", flush=True)
print("  d_ITD(gcc)  = ITD error via GCC-PHAT (microseconds)", flush=True)
print("  Lower=better:  TD Loss, d_ILD, d_ITD(xcorr), d_ITD(gcc)", flush=True)
print("  N/A = metric not available for that model", flush=True)
print('='*170, flush=True)