#!/usr/bin/env python3
"""One forward pass of an F12 checkpoint, then pool/threshold variants. No training, no stage 2."""

import argparse
import os
import sys

import numpy as np
import torch

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from method.frame_asd import mil_pool_logits, search_dual_threshold
from util.frame_asd_train import (
    _encode_batch,
    _unpack_batch,
    args_from_run_dir,
    build_loaders,
    build_model,
    set_seed,
)
from util.metrics import compute_class_metrics


def collect_logits(model, head, loader, device):
    model.eval()
    head.eval()
    chunks_c, chunks_w, labels, devices, locs = [], [], [], [], []
    with torch.no_grad():
        for batch in loader:
            waves, y, _pid, padding_mask, device_id, loc_id = _unpack_batch(batch)
            waves = waves.to(device, non_blocking=True)
            frames, _ = _encode_batch(model, waves, None)
            logit_c, logit_w = head(frames)
            chunks_c.append(logit_c.float().cpu())
            chunks_w.append(logit_w.float().cpu())
            labels.extend(y.tolist())
            if device_id is None:
                devices.extend([0] * y.size(0))
                locs.extend([0] * y.size(0))
            else:
                devices.extend(device_id.tolist())
                locs.extend(loc_id.tolist())
    return torch.cat(chunks_c, 0).numpy(), torch.cat(chunks_w, 0).numpy(), labels, devices, locs


def pool_np(logits, mode, topk):
    x = torch.from_numpy(logits)
    if mode == 'mean':
        return torch.sigmoid(x.mean(dim=1)).numpy()
    pooled = mil_pool_logits(x, mode='topk' if mode == 'topk' else 'max', topk=topk)
    return torch.sigmoid(pooled).numpy()


def report(name, p_c, p_w, labels, min_se, min_sp, n_points):
    dual = search_dual_threshold(p_c, p_w, labels, n_points=n_points, min_se=min_se, min_sp=min_sp)
    free = search_dual_threshold(p_c, p_w, labels, n_points=n_points, min_se=0, min_sp=0)
    preds = []
    from method.frame_asd import predict_with_thresholds
    preds = predict_with_thresholds(p_c, p_w, dual['tau_crackle'], dual['tau_wheeze'])
    metrics = compute_class_metrics(labels, preds)
    abn = metrics['abnormal_recalls']
    print(
        '{:<16} constrained {:.2f} (Sp {:.1f} Se {:.1f} cra {:.1f} whe {:.1f} both {:.1f} tau {:.2f}/{:.2f} fb {})'
        ' | free {:.2f} (Sp {:.1f} Se {:.1f})'.format(
            name, dual['score'], dual['sp'], dual['se'],
            abn['crackle'], abn['wheeze'], abn['both'],
            dual['tau_crackle'], dual['tau_wheeze'], dual.get('constraint_fallback'),
            free['score'], free['sp'], free['se']))
    return dual


def per_group_oracle(p_c, p_w, labels, groups, min_se, min_sp, n_points):
    """Search a dual threshold inside each group. This is an upper bound, not the official score."""
    labels = np.asarray(labels)
    groups = np.asarray(groups)
    preds = np.zeros(len(labels), dtype=np.int64)
    from method.frame_asd import predict_with_thresholds
    for gid in sorted(set(groups.tolist())):
        idx = np.where(groups == gid)[0]
        if len(idx) < 8:
            continue
        dual = search_dual_threshold(
            p_c[idx], p_w[idx], labels[idx].tolist(),
            n_points=n_points, min_se=0, min_sp=0)
        local = predict_with_thresholds(p_c[idx], p_w[idx], dual['tau_crackle'], dual['tau_wheeze'])
        preds[idx] = np.asarray(local, dtype=np.int64)
    metrics = compute_class_metrics(labels.tolist(), preds.tolist())
    print('group-oracle     Score {:.2f} Sp {:.1f} Se {:.1f} cra {:.1f} whe {:.1f} both {:.1f}'.format(
        metrics['score'], metrics['sp'], metrics['se'],
        metrics['abnormal_recalls']['crackle'],
        metrics['abnormal_recalls']['wheeze'],
        metrics['abnormal_recalls']['both']))


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--run_dir', required=True)
    parser.add_argument('--checkpoint', default=None)
    args_cli = parser.parse_args()
    run_dir = args_cli.run_dir
    ckpt_path = args_cli.checkpoint or os.path.join(run_dir, 'best.pth')
    args = args_from_run_dir(run_dir, overrides={'num_workers': 2, 'meta_cond': False})
    set_seed(args.seed)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    _train_loader, val_loader, _test_loader, train_set = build_loaders(args, print_flag=False)
    model, head, _criterion, _optimizer, _refiner = build_model(args, train_set, device)
    ckpt = torch.load(ckpt_path, map_location=device, weights_only=False)
    model.load_state_dict(ckpt['model'], strict=True)
    head.load_state_dict(ckpt['classifier'], strict=True)
    print('Loaded', ckpt_path, 'epoch', ckpt.get('epoch'))
    logit_c, logit_w, labels, _devices, _locs = collect_logits(model, head, val_loader, device)
    ds = val_loader.dataset
    devices = [int(ds.audio_images[i][2]) for i in range(len(ds))]
    locs = [int(ds.audio_images[i][4]) if len(ds.audio_images[i]) > 4 else 0 for i in range(len(ds))]
    print('logits', logit_c.shape, 'labels', len(labels))
    n_points = int(getattr(args, 'threshold_n_points', 41))
    min_se, min_sp = float(args.min_se), float(args.min_sp)
    for k in (1, 2, 3, 5, 8, 12, 16):
        p_c = pool_np(logit_c, 'topk', k)
        p_w = pool_np(logit_w, 'topk', k)
        report('topk {}'.format(k), p_c, p_w, labels, min_se, min_sp, n_points)
    p_c = pool_np(logit_c, 'mean', 1)
    p_w = pool_np(logit_w, 'mean', 1)
    report('mean', p_c, p_w, labels, min_se, min_sp, n_points)
    for kc, kw in ((3, 8), (3, 12), (2, 8), (5, 3), (3, 1)):
        p_c = pool_np(logit_c, 'topk', kc)
        p_w = pool_np(logit_w, 'topk', kw)
        report('c{} w{}'.format(kc, kw), p_c, p_w, labels, min_se, min_sp, n_points)
    p_c = pool_np(logit_c, 'topk', 3)
    p_w = pool_np(logit_w, 'topk', 3)
    print('--- device oracle on topk3 (not the official single-threshold score) ---')
    per_group_oracle(p_c, p_w, labels, devices, min_se, min_sp, n_points)
    print('--- location oracle on topk3 ---')
    per_group_oracle(p_c, p_w, labels, locs, min_se, min_sp, n_points)


if __name__ == '__main__':
    main()
