#!/usr/bin/env python3
"""Stage 2 only. Stage 1 stays in train.py and scripts/f12_s1.sh."""

import argparse
import json
import math
import os
import time
import warnings

import torch

from method.feedback_decoder import (
    attach_stage2,
    encoder_layers,
    entropy_anchor_weights,
    normal_anchor_loss,
    unfreeze_encoder_tail,
    wheeze_consistency_loss,
)
from util.frame_asd_train import (
    add_frame_asd_args,
    build_loaders,
    build_model,
    class_to_binary_targets,
    evaluate,
    load_checkpoint,
    set_seed,
    to_4class,
    update_refiner_average,
    probs_from_logits,
    _energy_mask,
    _frame_logits,
)
from util.misc import AverageMeter, save_model, update_json

warnings.filterwarnings('ignore')

F12_SCORE_FLOOR = -1.0
ENCODER_LR = 1e-5
DECODER_LR = 1e-4
TAIL_LAYERS = 0
NORMAL_ANCHOR = 0.0
CONSISTENCY = 0.1
REASON = 0.05
MA_BETA = 0.5


def parse_args():
    parser = argparse.ArgumentParser('F12 feedback stage 2')
    add_frame_asd_args(parser)
    parser.add_argument('--entropy_anchor', action='store_true', default=False,
                        help='Weight BCE by detached pass-1 four-class entropy over the batch mean.')
    parser.add_argument('--entropy_layer', type=int, default=11,
                        help='BEATs block whose pass-1 MIL entropy supplies the anchor weight.')
    parser.add_argument('--wheeze_consistency', action='store_true', default=False,
                        help='Consistency MSE anchors only the wheeze logit.')
    parser.add_argument('--encoder_tail_layers', type=int, default=0,
                        help='Last BEATs blocks trained with the crackle residual. 0 keeps the encoder frozen.')
    parser.add_argument('--tail_lr', type=float, default=1e-5,
                        help='Learning rate for the unfrozen BEATs tail. The head and residual use --learning_rate.')
    return parser.parse_args()


def _tail_parameters(model):
    layers = encoder_layers(model)
    if layers is None or len(layers) == 0:
        return []
    n = min(TAIL_LAYERS, len(layers))
    return [param for layer in layers[-n:] for param in layer.parameters() if param.requires_grad]


def _build_optimizer(args, model, refiner, head):
    if getattr(args, 'crackle_flux', False) and getattr(head, 'crackle_flux', None) is not None:
        for param in model.parameters():
            param.requires_grad = False
        for param in refiner.parameters():
            param.requires_grad = False
        for param in head.parameters():
            param.requires_grad = False
        for param in refiner.head2.parameters():
            param.requires_grad = True
        for param in head.crackle_flux.parameters():
            param.requires_grad = True
        n_tail = int(getattr(args, 'encoder_tail_layers', 0) or 0)
        tail_params = unfreeze_encoder_tail(model, n_layers=n_tail) if n_tail > 0 else []
        if n_tail > 0 and not tail_params:
            raise SystemExit('encoder_tail_layers {} found no BEATs blocks'.format(n_tail))
        lr = float(args.learning_rate)
        tail_lr = float(getattr(args, 'tail_lr', 1e-5) or 1e-5)
        head_params = [param for param in refiner.head2.parameters() if param.requires_grad]
        flux_params = [param for param in head.crackle_flux.parameters() if param.requires_grad]
        print('crackle flux + pass-2 linear head: {} head tensors, {} flux tensors, lr {:.1e}'.format(
            len(head_params), len(flux_params), lr))
        print('BEATs tail blocks {} ({} tensors) lr {:.1e}; earlier blocks, pass-1 head, and slots stay frozen'.format(
            n_tail, len(tail_params), tail_lr))
        groups = [
            {'params': head_params, 'lr': lr, 'base_lr': lr},
            {'params': flux_params, 'lr': lr, 'base_lr': lr},
        ]
        if tail_params:
            groups.append({'params': tail_params, 'lr': tail_lr, 'base_lr': tail_lr})
        return torch.optim.Adam(groups, weight_decay=args.weight_decay)
    encoder_params = _tail_parameters(model)
    refiner_params = [param for param in refiner.parameters() if param.requires_grad]
    groups = []
    if encoder_params:
        groups.append({'params': encoder_params, 'lr': ENCODER_LR, 'base_lr': ENCODER_LR})
    groups.append({'params': refiner_params, 'lr': DECODER_LR, 'base_lr': DECODER_LR})
    return torch.optim.Adam(groups, weight_decay=args.weight_decay)


def _apply_cosine(optimizer, epoch, epochs, lr_decay_rate):
    for group in optimizer.param_groups:
        base = group['base_lr']
        eta_min = base * (lr_decay_rate ** 3)
        group['lr'] = eta_min + (base - eta_min) * (1.0 + math.cos(math.pi * epoch / epochs)) / 2.0


def _set_train_mode(model, head, refiner):
    """A frozen encoder stays in eval, so SpecAug stays off. The refiner trains."""
    head.eval()
    refiner.train()
    if TAIL_LAYERS <= 0:
        model.eval()
        return
    model.train()
    layers = encoder_layers(model)
    if layers is None:
        return
    encoder = model.beats.encoder
    encoder.eval()
    n = min(TAIL_LAYERS, len(layers))
    for layer in layers[-n:]:
        layer.train()


def train_one_epoch(model, head, refiner, criterion, loader, optimizer, device, epoch, args):
    if getattr(args, 'crackle_flux', False) and getattr(head, 'crackle_flux', None) is not None:
        head.eval()
        refiner.eval()
        refiner.head2.train()
        head.crackle_flux.train()
        n_tail = int(getattr(args, 'encoder_tail_layers', 0) or 0)
        if n_tail <= 0:
            model.eval()
        else:
            model.train()
            layers = encoder_layers(model)
            encoder = model.beats.encoder
            encoder.eval()
            for layer in list(layers)[-n_tail:]:
                layer.train()
    else:
        _set_train_mode(model, head, refiner)
    loss_meter = AverageMeter()
    acc_meter = AverageMeter()
    confusion = torch.zeros(4, 4, device=device)

    for i, (waves, labels, patient_ids) in enumerate(loader):
        waves = waves.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True)
        logit_c, logit_w, refined = _frame_logits(head, None, refiner, waves)
        y_c, y_w = class_to_binary_targets(labels)
        emask = _energy_mask(waves, logit_c.size(1), args)
        sample_weight = None
        if args.entropy_anchor:
            sample_weight = entropy_anchor_weights(
                refined['logit_c_ent'], refined['logit_w_ent'],
                mil_pool=args.mil_pool, mil_topk=args.mil_topk)
        loss, _ = criterion(
            logit_c, logit_w, y_c, y_w, energy_mask=emask, sample_weight=sample_weight)
        if args.lambda_reason > 0:
            loss = loss + args.lambda_reason * refined['reason_loss']
        if args.lambda_consistency > 0:
            if args.wheeze_consistency:
                consistency = wheeze_consistency_loss(
                    refined['logit_c1'], refined['logit_w1'], logit_c, logit_w)
            else:
                consistency = refined['consistency']
            loss = loss + args.lambda_consistency * consistency
        if args.lambda_normal_anchor > 0:
            loss = loss + args.lambda_normal_anchor * normal_anchor_loss(
                refined['logit_c1'], refined['logit_w1'], logit_c, logit_w, labels == 0)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        with torch.no_grad():
            p_c, p_w = probs_from_logits(
                logit_c, logit_w, mode=args.mil_pool, topk=args.mil_topk, energy_mask=emask)
            preds = [to_4class(p_c[j].item(), p_w[j].item()) for j in range(labels.size(0))]
            acc = sum(int(p == int(t)) for p, t in zip(preds, labels.cpu().tolist())) / labels.size(0) * 100
            for truth, pred in zip(labels.cpu().tolist(), preds):
                confusion[int(truth), int(pred)] += 1

        loss_meter.update(loss.item(), waves.size(0))
        acc_meter.update(acc, waves.size(0))
        if (i + 1) % args.print_freq == 0:
            print('Train: [{}][{}/{}]\tLoss {:.3f} ({:.3f})\tAcc {:.2f}'.format(
                epoch, i + 1, len(loader), loss_meter.val, loss_meter.avg, acc_meter.avg))

    if refiner.use_confusion_prior:
        refiner.update_confusion(confusion)
    return loss_meter.avg, acc_meter.avg


def main():
    args = parse_args()
    if not args.resume:
        raise SystemExit('Set --resume to an F12 best.pth (Score 66.32).')
    args.feedback_stage = 2
    if not getattr(args, 'crackle_flux', False):
        args.encoder_tail_layers = TAIL_LAYERS
    args.w_wheeze = 1.0
    args.lambda_both = 0.0
    args.lambda_reason = REASON
    args.lambda_normal_anchor = NORMAL_ANCHOR
    args.lambda_consistency = CONSISTENCY
    args.ma_update = True
    args.ma_beta = MA_BETA
    set_seed(args.seed)
    args.model_name = 'icbhi_{}_{}_{}'.format(args.model, args.method, args.tag)
    args.save_folder = os.path.join(args.save_dir, args.model_name)
    os.makedirs(args.save_folder, exist_ok=True)
    with open(os.path.join(args.save_folder, 'train_args.json'), 'w') as f:
        json.dump(vars(args), f, indent=2)

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print('Using device:', device)
    print('Stage 2 encoder frozen, decoder lr {:.1e}, consistency {:.2f}, reason {:.2f}'.format(
        DECODER_LR, args.lambda_consistency, args.lambda_reason))
    print('Frame layer {} slot layer {}'.format(args.frame_layer, args.slot_layer))
    if args.entropy_anchor:
        print('Entropy anchor on layer {}'.format(args.entropy_layer))
    if args.wheeze_consistency:
        print('Wheeze-only consistency: MSE is logit_w2 - logit_w1.detach()')

    train_loader, val_loader, _, train_set = build_loaders(args)
    # build_model stays on the stage-1 path. The refiner is attached only here.
    # The crackle residual is attached after the stage-2 copy so it is not frozen
    # into both heads and is not required by an older checkpoint.
    saved_stage = args.feedback_stage
    saved_flux = bool(getattr(args, 'crackle_flux', False))
    args.feedback_stage = 0
    args.crackle_flux = False
    model, head, criterion, _, _ = build_model(args, train_set, device)
    args.feedback_stage = saved_stage
    args.crackle_flux = saved_flux
    n_blocks = len(encoder_layers(model) or [])
    for name, index in (('frame_layer', args.frame_layer), ('slot_layer', args.slot_layer)):
        if index < 0 or index >= n_blocks:
            raise SystemExit('{} {} is outside 0..{}'.format(name, index, n_blocks - 1))
    if args.entropy_anchor and (args.entropy_layer < 0 or args.entropy_layer >= n_blocks):
        raise SystemExit('entropy_layer {} is outside 0..{}'.format(args.entropy_layer, n_blocks - 1))
    refiner = attach_stage2(model, head, args, device)
    refiner.use_confusion_prior = True
    refiner.frame_layer = int(args.frame_layer)
    refiner.slot_layer = int(args.slot_layer)
    refiner.entropy_layer = int(args.entropy_layer) if args.entropy_anchor else None
    refiner.self_feedback.key_drop = 0.0
    refiner.self_feedback.use_timbre = False
    print('feedback stage 2: requested encoder tail blocks {}; pass-1 head frozen'.format(
        int(args.encoder_tail_layers)))

    load_checkpoint(args, model, head, None, device, refiner=refiner)
    # Register the encoder only after the refiner state is loaded. Older
    # checkpoints do not store a copy of BEATs inside the feedback blob.
    refiner.layer_encoder = model
    if args.crackle_flux:
        from method.crackle_flux import CrackleFluxResidual
        head.crackle_flux = CrackleFluxResidual(
            sample_rate=int(getattr(args, 'sample_rate', 16000))).to(device)
    optimizer = _build_optimizer(args, model, refiner, head)
    print('reset_epoch_on_resume: starting from epoch 1')
    print('Training for {} epochs. The run records its best epoch.'.format(args.epochs))

    if getattr(args, 'eval_first', False) or int(args.epochs) <= 0:
        metrics, _, _, _ = evaluate(
            model, head, criterion, val_loader, device, args, refiner=refiner)
        abn = metrics['abnormal_recalls']
        print('Eval before train: Score {:.2f} Sp {:.1f} Se {:.1f} | cra {:.1f} whe {:.1f} both {:.1f}'.format(
            metrics['score'], metrics['sp'], metrics['se'],
            abn['crackle'], abn['wheeze'], abn['both']))
    if int(args.epochs) <= 0:
        print('No training epoch ran. The Score above is the resumed checkpoint.')
        return

    best_score = F12_SCORE_FLOOR
    best_metrics = None
    stale = 0
    ma_ckpt = None
    for epoch in range(1, args.epochs + 1):
        _apply_cosine(optimizer, epoch, args.epochs, args.lr_decay_rate)
        t0 = time.time()
        train_loss, train_acc = train_one_epoch(
            model, head, refiner, criterion, train_loader, optimizer, device, epoch, args)
        print('Train epoch {}, time {:.2f}s, loss {:.3f}, acc {:.2f}'.format(
            epoch, time.time() - t0, train_loss, train_acc))

        metrics, _, _, dual = evaluate(
            model, head, criterion, val_loader, device, args, refiner=refiner)
        abn = metrics['abnormal_recalls']
        pmax = metrics.get('positive_prob_max') or {}
        print('Val: Score {:.2f} Sp {:.1f} Se {:.1f} | cra {:.1f} whe {:.1f} both {:.1f} n→whe_fp {} | tau_c={:.3f} tau_w={:.3f} | pmax_c={:.3f} pmax_w={:.3f}'.format(
            metrics['score'], metrics['sp'], metrics['se'],
            abn['crackle'], abn['wheeze'], abn['both'], metrics['normal_wheeze_fp'],
            metrics['tau_crackle'], metrics['tau_wheeze'],
            float(pmax.get('crackle', 0.0)), float(pmax.get('wheeze', 0.0))))

        if metrics['score'] > best_score:
            best_score = metrics['score']
            best_metrics = metrics
            stale = 0
            save_model(model, optimizer, args, epoch,
                       os.path.join(args.save_folder, 'best.pth'), head, feedback=refiner)
            with open(os.path.join(args.save_folder, 'best_threshold.json'), 'w') as f:
                json.dump({
                    'tau_crackle': dual['tau_crackle'],
                    'tau_wheeze': dual['tau_wheeze'],
                    'sp': dual['sp'],
                    'se': dual['se'],
                    'score': dual['score'],
                    'min_se': args.min_se,
                    'min_sp': args.min_sp,
                }, f, indent=2)
            with open(os.path.join(args.save_folder, 'class_metrics.json'), 'w') as f:
                json.dump(best_metrics, f, indent=2)
            print('New best Score {:.2f}'.format(best_score))
        else:
            stale += 1
            print('Skip best: Score {:.2f} is not above {:.2f}'.format(metrics['score'], best_score))

        if args.ma_update:
            ma_ckpt = update_refiner_average(args.ma_beta, refiner, ma_ckpt)
        if stale >= args.early_stop_patience:
            print('Early stopping after {} epochs without improvement'.format(stale))
            break

    if best_metrics:
        update_json(args.model_name, [
            best_metrics['sp'], best_metrics['se'], best_metrics['score'], 0.0])
    print('Finished. Best Score: {:.2f}'.format(best_score))


if __name__ == '__main__':
    main()
