from __future__ import annotations

import numpy as np
import pytest
import torch

from gmnet.spectral.metrics import measure_spectrum
from gmnet.spectral.streaming import RadialPSDAccumulator, torch_fft_lowpass
from gmnet.spectral.transforms import (
    dct_coefficients,
    dct_reconstruct,
    fft_coefficients,
    fft_reconstruct,
    hard_band_reconstruction,
    haar_decompose2d,
    haar_reconstruct2d,
    relative_l2_error,
)


@pytest.mark.parametrize("shape", [(2, 3, 32, 32), (1, 1, 16, 24)])
def test_transforms_are_numerically_invertible(shape: tuple[int, ...]) -> None:
    x = np.random.default_rng(7).standard_normal(shape)
    fft_result = fft_reconstruct(fft_coefficients(x))
    dct_result = dct_reconstruct(dct_coefficients(x))
    haar_result = haar_reconstruct2d(haar_decompose2d(x, levels=3))
    assert relative_l2_error(x, fft_result) < 1e-12
    assert relative_l2_error(x, dct_result) < 1e-12
    assert relative_l2_error(x, haar_result) < 1e-12
    assert relative_l2_error(
        x, hard_band_reconstruction(x, "fft", (0.0, 0.25, 0.5, 1.0))
    ) < 1e-12
    assert relative_l2_error(
        x, hard_band_reconstruction(x, "dct", (0.0, 0.25, 0.5, 1.0))
    ) < 1e-12


def test_parseval_energy_is_preserved() -> None:
    x = np.random.default_rng(11).standard_normal((2, 2, 32, 32))
    reference = float(np.square(x).sum())
    assert np.isclose(np.square(np.abs(fft_coefficients(x))).sum(), reference)
    assert np.isclose(np.square(dct_coefficients(x)).sum(), reference)
    wavelet = haar_decompose2d(x, levels=3)
    wavelet_energy = np.square(wavelet.approximation).sum() + sum(
        np.square(detail).sum() for level in wavelet.details for detail in level
    )
    assert np.isclose(wavelet_energy, reference)


def test_high_frequency_tone_scores_above_low_frequency_tone() -> None:
    grid = np.arange(64)
    low = np.sin(2 * np.pi * 2 * grid / 64)[None, None, None, :]
    high = np.sin(2 * np.pi * 24 * grid / 64)[None, None, None, :]
    low = np.broadcast_to(low, (1, 1, 64, 64))
    high = np.broadcast_to(high, (1, 1, 64, 64))
    for method in ("fft", "dct", "haar"):
        assert measure_spectrum(high, method).frequency_auc > measure_spectrum(
            low, method
        ).frequency_auc


def test_invalid_haar_shape_is_rejected() -> None:
    with pytest.raises(ValueError, match="divisible"):
        haar_decompose2d(np.ones((10, 10)), levels=2)


def test_streaming_psd_orders_low_and_high_tones() -> None:
    grid = torch.arange(32, dtype=torch.float32)
    low = torch.sin(2 * torch.pi * 2 * grid / 32)[None, None, None, :]
    high = torch.sin(2 * torch.pi * 12 * grid / 32)[None, None, None, :]
    low = low.expand(2, 3, 32, 32)
    high = high.expand(2, 3, 32, 32)
    low_accumulator = RadialPSDAccumulator()
    high_accumulator = RadialPSDAccumulator()
    low_accumulator.update(low[:1])
    low_accumulator.update(low[1:])
    high_accumulator.update(high)
    low_result = low_accumulator.compute()
    high_result = high_accumulator.compute()
    assert low_result.valid and high_result.valid
    assert high_result.spectral_centroid > low_result.spectral_centroid
    assert high_result.high_low_ratio > low_result.high_low_ratio


def test_streaming_psd_marks_one_by_one_features_invalid() -> None:
    accumulator = RadialPSDAccumulator()
    accumulator.update(torch.randn(2, 4, 1, 1))
    result = accumulator.compute()
    assert not result.valid
    assert result.spectral_centroid is None


def test_streaming_psd_rejects_constant_roundoff_and_degenerate_split() -> None:
    constant = RadialPSDAccumulator()
    constant.update(torch.ones(2, 3, 32, 32) * 0.3)
    assert not constant.compute().valid
    tiny_grid = RadialPSDAccumulator()
    tiny_grid.update(torch.randn(2, 3, 2, 2))
    result = tiny_grid.compute()
    assert result.valid
    assert not result.high_low_valid
    assert result.high_low_ratio is None


def test_torch_lowpass_endpoints_and_attenuation() -> None:
    images = torch.randn(2, 3, 32, 32)
    dc = torch_fft_lowpass(images, 0.0)
    identity = torch_fft_lowpass(images, 1.0)
    filtered = torch_fft_lowpass(images, 0.25)
    assert torch.allclose(dc, images.mean(dim=(-2, -1), keepdim=True).expand_as(images))
    assert identity.data_ptr() == images.data_ptr()
    assert filtered.square().mean() < images.square().mean()