"""Thin BEATs backbone for Frame ASD (no HFTT layers)."""

import torch
import torch.nn as nn
from BEATs.BEATs import BEATs, BEATsConfig


class BeatsEncoder(nn.Module):
    def __init__(
        self,
        num_target_classes: int = 4,
        beats_model_path: str = './pretrained_models/BEATs_iter3_plus_AS2M.pt',
        freeze_encoder: bool = False,
        spec_transform=None,
        frame_multiscale: bool = False,
        wave_scale: float = 1.0,
        specaug_axis_fix: bool = False,
        fbank_mean=None,
        fbank_std=None,
        layer_decay: float = 1.0,
    ):
        super().__init__()
        if frame_multiscale:
            raise ValueError('frame_multiscale is not supported for BeatsEncoder')

        checkpoint = torch.load(beats_model_path, map_location='cpu')
        cfg = BEATsConfig({
            **checkpoint['cfg'],
            'predictor_class': num_target_classes,
            'finetuned_model': False,
            'spec_transform': spec_transform,
        })
        self.beats = BEATs(cfg)
        self.beats.load_state_dict(checkpoint['model'])
        self.beats.wave_scale = float(wave_scale)
        self.beats.specaug_axis_fix = bool(specaug_axis_fix)
        if freeze_encoder:
            for param in self.beats.parameters():
                param.requires_grad = False
        self.layer_decay = float(layer_decay)
        self.beats.encoder.layer_wise_gradient_decay_ratio = self.layer_decay

        self.encoder_dim = cfg.encoder_embed_dim
        self.final_feat_dim = self.encoder_dim
        self.feature_layer = len(self.beats.encoder.layers) - 1
        self.feature_layer_aux = None
        self.frame_dim = self.encoder_dim

        # Dataset fbank stats (scalar or per-mel-bin [128]); None keeps the AudioSet constants.
        # Non-persistent so checkpoints stay loadable with strict=True either way.
        self.custom_fbank_stats = fbank_mean is not None
        if self.custom_fbank_stats:
            self.register_buffer('fbank_mean', torch.as_tensor(fbank_mean, dtype=torch.float32), persistent=False)
            self.register_buffer('fbank_std', torch.as_tensor(fbank_std, dtype=torch.float32), persistent=False)

    def configure_feature_layers(self, feature_layer, feature_layer_aux=None):
        """Read one block, or concat that block with an earlier block. Default is the last block."""
        n_layers = len(self.beats.encoder.layers)
        feature_layer = int(feature_layer)
        if feature_layer < 0 or feature_layer >= n_layers:
            raise ValueError('feature_layer {} is outside 0..{}'.format(feature_layer, n_layers - 1))
        if feature_layer_aux is not None and int(feature_layer_aux) < 0:
            feature_layer_aux = None
        if feature_layer_aux is not None:
            feature_layer_aux = int(feature_layer_aux)
            if feature_layer_aux < 0 or feature_layer_aux >= n_layers:
                raise ValueError('feature_layer_aux {} is outside 0..{}'.format(
                    feature_layer_aux, n_layers - 1))
            if feature_layer_aux == feature_layer:
                raise ValueError('feature_layer_aux must differ from feature_layer')
        self.feature_layer = feature_layer
        self.feature_layer_aux = feature_layer_aux
        self.frame_dim = self.encoder_dim if feature_layer_aux is None else self.encoder_dim * 2

    def _extract(self, source, padding_mask, spec_labels, all_layers):
        kwargs = {
            'padding_mask': padding_mask,
            'spec_labels': spec_labels,
            'all_layers': all_layers,
        }
        if self.custom_fbank_stats:
            kwargs['fbank_mean'] = self.fbank_mean
            kwargs['fbank_std'] = self.fbank_std
        return self.beats.extract_features(source, **kwargs)

    def encode_all_layers(self, source, padding_mask=None, spec_labels=None):
        """One tensor [B, T, D] after each transformer block. Index 0 is the first block."""
        layers, _ = self._extract(source, padding_mask, spec_labels, all_layers=True)
        return layers

    def encode_frames(self, source, padding_mask=None, spec_labels=None):
        """Return per-frame features [B, T, D] from BEATs only."""
        last = len(self.beats.encoder.layers) - 1
        if self.feature_layer == last and self.feature_layer_aux is None:
            _x, _ = self._extract(source, padding_mask, spec_labels, all_layers=False)
            return _x
        layers = self.encode_all_layers(source, padding_mask, spec_labels)
        frames = layers[self.feature_layer]
        if self.feature_layer_aux is None:
            return frames
        return torch.cat([frames, layers[self.feature_layer_aux]], dim=-1)

    def forward(self, source, padding_mask=None, training=False):
        x = self.encode_frames(source, padding_mask)
        return x.mean(dim=1, keepdim=True)


def get_beats_model(
    beats_model_path='./pretrained_models/BEATs_iter3_plus_AS2M.pt',
    freeze_encoder=False,
    spec_transform=None,
    frame_multiscale=False,
    wave_scale=1.0,
    specaug_axis_fix=False,
    fbank_mean=None,
    fbank_std=None,
    layer_decay=1.0,
):
    return BeatsEncoder(
        num_target_classes=4,
        beats_model_path=beats_model_path,
        freeze_encoder=freeze_encoder,
        spec_transform=spec_transform,
        frame_multiscale=frame_multiscale,
        wave_scale=wave_scale,
        specaug_axis_fix=specaug_axis_fix,
        fbank_mean=fbank_mean,
        fbank_std=fbank_std,
        layer_decay=layer_decay,
    )
