"""Frame-level adventitious sound detection with MIL pooling per cycle."""

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from util.metrics import get_score


def class_to_binary_targets(class_labels):
    labels = class_labels.long()
    crackle = ((labels == 1) | (labels == 3)).float()
    wheeze = ((labels == 2) | (labels == 3)).float()
    return crackle, wheeze


def align_frame_energy(waves, n_frames):
    """Per-frame RMS energy aligned to BEATs frame count [B, T]."""
    B, length = waves.shape
    chunk = max(1, length // n_frames)
    pad_len = chunk * n_frames
    if pad_len > length:
        waves = F.pad(waves, (0, pad_len - length))
    else:
        waves = waves[:, :pad_len]
    x = waves.view(B, n_frames, chunk)
    return x.pow(2).mean(dim=-1)


def energy_mask_top_frac(energy, top_frac=0.4):
    """Keep top energy frames; at least one frame per sample."""
    B, T = energy.shape
    k = max(1, int(T * top_frac))
    thresh = energy.topk(k, dim=1).values[:, -1].unsqueeze(1)
    return energy >= thresh


def mil_pool_logits(logits, mode='max', topk=3, energy_mask=None, padding_mask=None):
    """MIL aggregation over time dimension.

    padding_mask True marks a padded frame and is excluded from the pool.
    """
    x = logits
    if energy_mask is not None:
        x = x.masked_fill(~energy_mask, float('-inf'))
    if mode == 'topk':
        k = min(topk, x.size(1))
        topv, _ = x.topk(k, dim=1)
        return topv.mean(dim=1)
    return x.max(dim=1).values


def probs_from_logits(logit_c, logit_w, mode='max', topk=3, energy_mask=None, padding_mask=None):
    p_c = torch.sigmoid(mil_pool_logits(logit_c, mode, topk, energy_mask, padding_mask))
    p_w = torch.sigmoid(mil_pool_logits(logit_w, mode, topk, energy_mask, padding_mask))
    return p_c, p_w


def to_4class(p_crackle, p_wheeze, tau_c=0.5, tau_w=0.5):
    c = float(p_crackle) >= tau_c
    w = float(p_wheeze) >= tau_w
    if not c and not w:
        return 0
    if c and not w:
        return 1
    if not c and w:
        return 2
    return 3


def predict_with_thresholds(p_crackle, p_wheeze, tau_c, tau_w):
    return [to_4class(p_crackle[i], p_wheeze[i], tau_c, tau_w)
            for i in range(len(p_crackle))]


def search_dual_threshold(p_crackle, p_wheeze, labels, n_points=21,
                          min_se=0.0, min_sp=0.0):
    labels = [int(x) for x in labels]
    taus = np.linspace(0.15, 0.95, n_points)
    best = {'tau_crackle': 0.5, 'tau_wheeze': 0.5, 'sp': 0.0, 'se': 0.0, 'score': -1.0}
    best_unconstrained = dict(best)

    p_c = np.asarray(p_crackle, dtype=np.float64)
    p_w = np.asarray(p_wheeze, dtype=np.float64)

    for tau_c in taus:
        for tau_w in taus:
            preds = predict_with_thresholds(p_c, p_w, float(tau_c), float(tau_w))
            hits = [0.0] * 4
            counts = [0.0] * 4
            for t, p in zip(labels, preds):
                counts[t] += 1.0
                if t == p:
                    hits[t] += 1.0
            sp, se, sc, _ = get_score(hits, counts)
            result = {
                'tau_crackle': float(tau_c),
                'tau_wheeze': float(tau_w),
                'sp': sp,
                'se': se,
                'score': sc,
            }
            if sc > best_unconstrained['score']:
                best_unconstrained = result
            if se >= min_se and sp >= min_sp and sc > best['score']:
                best = result

    if best['score'] < 0:
        best = best_unconstrained
        best['constraint_fallback'] = True
    else:
        best['constraint_fallback'] = False
    best['min_se'] = min_se
    best['min_sp'] = min_sp
    return best


def focal_bce_with_logits(logits, targets, gamma=2.0, pos_weight=None, reduction='mean'):
    bce = F.binary_cross_entropy_with_logits(
        logits, targets, pos_weight=pos_weight, reduction='none')
    p = torch.sigmoid(logits)
    p_t = p * targets + (1.0 - p) * (1.0 - targets)
    loss = ((1.0 - p_t) ** gamma) * bce
    if reduction == 'none':
        return loss
    return loss.mean()


def _mean_weighted(values, sample_weight):
    """Mean BCE. Weights are divided by their batch mean so all-ones matches the unweighted loss."""
    if sample_weight is None:
        return values.mean()
    weight = sample_weight.detach().reshape(-1).to(device=values.device, dtype=values.dtype)
    weight = weight / weight.mean().clamp(min=1e-6)
    return (values * weight).mean()


class FrameASDHead(nn.Module):
    def __init__(self, in_dim=768, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(dropout)
        self.crackle = nn.Linear(in_dim, 1)
        self.wheeze = nn.Linear(in_dim, 1)

    def forward(self, frames):
        x = self.dropout(frames)
        return self.crackle(x).squeeze(-1), self.wheeze(x).squeeze(-1)


class FrameASDMLPHead(nn.Module):
    """Shared MLP bottleneck (768→hidden→1) for crackle/wheeze frame logits."""

    def __init__(self, in_dim=768, hidden_dim=256, dropout=0.1):
        super().__init__()
        self.shared = nn.Sequential(
            nn.LayerNorm(in_dim),
            nn.Linear(in_dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
        )
        self.crackle = nn.Linear(hidden_dim, 1)
        self.wheeze = nn.Linear(hidden_dim, 1)

    def forward(self, frames):
        x = self.shared(frames)
        return self.crackle(x).squeeze(-1), self.wheeze(x).squeeze(-1)


def build_frame_asd_head(head_type, in_dim=768, hidden_dim=256, dropout=0.1,
                         temporal_layers=2, temporal_heads=8):
    if head_type == 'mlp':
        return FrameASDMLPHead(in_dim, hidden_dim, dropout)
    if head_type == 'temporal':
        from method.f12_temporal import FrameASDTemporalHead
        return FrameASDTemporalHead(
            in_dim=in_dim,
            n_layers=temporal_layers,
            n_heads=temporal_heads,
            dropout=dropout,
        )
    return FrameASDHead(in_dim, dropout)


class FrameASDLoss(nn.Module):
    def __init__(self, pos_weight_crackle=1.0, pos_weight_wheeze=1.0,
                 w_crackle=1.0, w_wheeze=1.0, mil_pool='max', mil_topk=3,
                 wheeze_focal=False, focal_gamma=2.0, lambda_both=0.0):
        super().__init__()
        self.register_buffer('pw_c', torch.tensor([pos_weight_crackle], dtype=torch.float32))
        self.register_buffer('pw_w', torch.tensor([pos_weight_wheeze], dtype=torch.float32))
        self.w_crackle = w_crackle
        self.w_wheeze = w_wheeze
        self.mil_pool = mil_pool
        self.mil_topk = mil_topk
        self.wheeze_focal = wheeze_focal
        self.focal_gamma = focal_gamma
        self.lambda_both = lambda_both

    def forward(self, logit_c, logit_w, y_crackle, y_wheeze, energy_mask=None,
                padding_mask=None, sample_weight=None):
        pooled_c = mil_pool_logits(
            logit_c, self.mil_pool, self.mil_topk, energy_mask, padding_mask)
        pooled_w = mil_pool_logits(
            logit_w, self.mil_pool, self.mil_topk, energy_mask, padding_mask)
        loss_c_vec = F.binary_cross_entropy_with_logits(
            pooled_c, y_crackle, pos_weight=self.pw_c, reduction='none')
        if self.wheeze_focal:
            loss_w_vec = focal_bce_with_logits(
                pooled_w, y_wheeze, gamma=self.focal_gamma, pos_weight=self.pw_w,
                reduction='none')
        else:
            loss_w_vec = F.binary_cross_entropy_with_logits(
                pooled_w, y_wheeze, pos_weight=self.pw_w, reduction='none')
        loss_c = _mean_weighted(loss_c_vec, sample_weight)
        loss_w = _mean_weighted(loss_w_vec, sample_weight)
        loss = self.w_crackle * loss_c + self.w_wheeze * loss_w
        extras = {
            'loss_crackle': loss_c.detach(),
            'loss_wheeze': loss_w.detach(),
        }
        if self.lambda_both > 0:
            y_both = y_crackle * y_wheeze
            cooc = torch.sigmoid(pooled_c) * torch.sigmoid(pooled_w)
            loss_both_vec = F.binary_cross_entropy(cooc, y_both, reduction='none')
            loss_both = _mean_weighted(loss_both_vec, sample_weight)
            loss = loss + self.lambda_both * loss_both
            extras['loss_both'] = loss_both.detach()
        return loss, extras
