"""Locked Ultralytics numerics with explicit sensor research constraints."""
from __future__ import annotations

import numpy as np
import torch

from .recipes import build_ultralytics_optimizer, resolve_ultralytics_auto


def validate_constraints(*, size, effective_batch, epochs, patience, mosaic,
                         warmup_epochs, min_lr_ratio):
    if (size != 640 or effective_batch != 16 or not 1 <= epochs <= 300
            or patience != 50 or mosaic or warmup_epochs != 3 or min_lr_ratio != .01):
        raise ValueError("official_research_constrained requires size=640, effective_batch=16, "
                         "1<=epochs<=300, patience=50, mosaic=False, warmup_epochs=3, min_lr_ratio=.01")


class YoloResearchRecipe:
    """Optimizer, epoch scheduler, warmup, criterion progression and EMA state.

    Accumulation is fixed at the nominal research batch of sixteen. Each epoch's
    short final window is multiplied by 16/actual_examples before backward.
    Thus full windows use upstream's unnormalized batch-summed loss verbatim.
    This differs from upstream accumulation ramp and cross-epoch pending grads.
    """

    def __init__(self, model, *, samples, epochs, batch_size, num_batches):
        from ultralytics.utils.torch_utils import ModelEMA

        self.model = model
        self.epochs = epochs
        self.resolved_optimizer = resolve_ultralytics_auto(
            num_train_samples=samples, epochs=epochs, batch_size=batch_size, nbs=16)
        self.optimizer = build_ultralytics_optimizer(
            model, num_train_samples=samples, epochs=epochs, batch_size=batch_size)
        self.lf = lambda epoch: max(1 - epoch / epochs, 0) * .99 + .01
        self.scheduler = torch.optim.lr_scheduler.LambdaLR(self.optimizer, self.lf)
        # Upstream steps at the start of each epoch with last_epoch=start-1.
        self.scheduler.last_epoch = -1
        self.warmup_iterations = round(min(3, max(epochs - 1, 0)) * num_batches)
        self.ema = ModelEMA(model)
        self.optimizer_updates = 0
        model.yolo.args.epochs = epochs
        model.yolo.criterion = model.yolo.init_criterion()

    def begin_epoch(self):
        import warnings
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", UserWarning)
            self.scheduler.step()

    def warmup(self, iteration, epoch):
        if iteration < self.warmup_iterations:
            for group in self.optimizer.param_groups:
                group["lr"] = float(np.interp(iteration, [0, self.warmup_iterations],
                                             [0., group["initial_lr"] * self.lf(epoch)]))
                # Auto selects momentum=.9, while trainer warmup targets args.momentum=.937.
                # Adam betas are deliberately not warmed in the locked trainer.
                if "momentum" in group:
                    group["momentum"] = float(np.interp(
                        iteration, [0, self.warmup_iterations], [.8, .937]))

    def after_step(self, successful):
        if successful:
            self.optimizer_updates += 1
            self.ema.update(self.model)

    def end_epoch(self):
        criterion = self.model.yolo.criterion
        if hasattr(criterion, "update"):
            criterion.update()

    def state_dict(self):
        return {"ema": self.ema.ema.state_dict(), "ema_updates": self.ema.updates,
                "optimizer_updates": self.optimizer_updates,
                "resolved_optimizer": self.resolved_optimizer,
                "criterion_updates": getattr(self.model.yolo.criterion, "updates", 0),
                "accumulation_policy": "fixed16_epoch_tail_rescale",
                "selection_model": "ema"}

    def load_state_dict(self, state):
        self.ema.ema.load_state_dict(state["ema"])
        self.ema.updates = state["ema_updates"]
        self.optimizer_updates = state["optimizer_updates"]
        criterion = self.model.yolo.criterion
        for _ in range(state["criterion_updates"]):
            criterion.update()
