"""Unit tests for app.services.indicator_service pure computation functions."""

import pytest

from app.exceptions import ValidationError
from app.services.indicator_service import (
    compute_adx,
    compute_atr,
    compute_ema,
    compute_ema_cross,
    compute_pivot_points,
    compute_rsi,
    compute_volume_profile,
)


# ---------------------------------------------------------------------------
# Helpers: generate synthetic OHLCV data
# ---------------------------------------------------------------------------

def _rising_closes(n: int, start: float = 100.0, step: float = 1.0) -> list[float]:
    return [start + i * step for i in range(n)]


def _flat_closes(n: int, price: float = 100.0) -> list[float]:
    return [price] * n


def _ohlcv_from_closes(closes: list[float], spread: float = 2.0):
    """Generate highs/lows/volumes from a close series."""
    highs = [c + spread for c in closes]
    lows = [c - spread for c in closes]
    volumes = [1000] * len(closes)
    return highs, lows, closes, volumes


# ---------------------------------------------------------------------------
# EMA
# ---------------------------------------------------------------------------

class TestComputeEMA:
    def test_basic_ema(self):
        closes = _rising_closes(25)
        result = compute_ema(closes, period=20)
        assert "ema" in result
        assert "score" in result
        assert 0 <= result["score"] <= 100

    def test_insufficient_data_raises(self):
        closes = _rising_closes(5)
        with pytest.raises(ValidationError, match="EMA.*requires at least"):
            compute_ema(closes, period=20)

    def test_price_above_ema_high_score(self):
        # Rising prices → latest close above EMA → score > 50
        closes = _rising_closes(30, start=100, step=2)
        result = compute_ema(closes, period=20)
        assert result["score"] > 50

    def test_price_below_ema_low_score(self):
        # Falling prices → latest close below EMA → score < 50
        closes = list(reversed(_rising_closes(30, start=100, step=2)))
        result = compute_ema(closes, period=20)
        assert result["score"] < 50


# ---------------------------------------------------------------------------
# RSI
# ---------------------------------------------------------------------------

class TestComputeRSI:
    def test_basic_rsi(self):
        closes = _rising_closes(20)
        result = compute_rsi(closes)
        assert "rsi" in result
        assert 0 <= result["score"] <= 100

    def test_all_gains_rsi_100(self):
        closes = _rising_closes(20, step=1)
        result = compute_rsi(closes)
        assert result["rsi"] == 100.0

    def test_all_losses_rsi_0(self):
        closes = list(reversed(_rising_closes(20, step=1)))
        result = compute_rsi(closes)
        assert result["rsi"] == pytest.approx(0.0, abs=0.5)

    def test_insufficient_data_raises(self):
        with pytest.raises(ValidationError, match="RSI requires"):
            compute_rsi([100.0] * 5)


# ---------------------------------------------------------------------------
# ATR
# ---------------------------------------------------------------------------

class TestComputeATR:
    def test_basic_atr(self):
        closes = _rising_closes(20)
        highs, lows, _, _ = _ohlcv_from_closes(closes)
        result = compute_atr(highs, lows, closes)
        assert "atr" in result
        assert result["atr"] > 0
        assert 0 <= result["score"] <= 100

    def test_insufficient_data_raises(self):
        closes = [100.0] * 5
        highs, lows, _, _ = _ohlcv_from_closes(closes)
        with pytest.raises(ValidationError, match="ATR requires"):
            compute_atr(highs, lows, closes)


# ---------------------------------------------------------------------------
# ADX
# ---------------------------------------------------------------------------

class TestComputeADX:
    def test_basic_adx(self):
        closes = _rising_closes(30)
        highs, lows, _, _ = _ohlcv_from_closes(closes)
        result = compute_adx(highs, lows, closes)
        assert "adx" in result
        assert "plus_di" in result
        assert "minus_di" in result
        assert 0 <= result["score"] <= 100

    def test_insufficient_data_raises(self):
        closes = _rising_closes(10)
        highs, lows, _, _ = _ohlcv_from_closes(closes)
        with pytest.raises(ValidationError, match="ADX requires"):
            compute_adx(highs, lows, closes)


# ---------------------------------------------------------------------------
# Volume Profile
# ---------------------------------------------------------------------------

class TestComputeVolumeProfile:
    def test_basic_volume_profile(self):
        closes = _rising_closes(25)
        highs, lows, _, volumes = _ohlcv_from_closes(closes)
        result = compute_volume_profile(highs, lows, closes, volumes)
        assert "poc" in result
        assert "value_area_low" in result
        assert "value_area_high" in result
        assert "hvn" in result
        assert "lvn" in result
        assert 0 <= result["score"] <= 100

    def test_insufficient_data_raises(self):
        closes = [100.0] * 10
        highs, lows, _, volumes = _ohlcv_from_closes(closes)
        with pytest.raises(ValidationError, match="Volume Profile requires"):
            compute_volume_profile(highs, lows, closes, volumes)


# ---------------------------------------------------------------------------
# Pivot Points
# ---------------------------------------------------------------------------

class TestComputePivotPoints:
    def test_basic_pivot_points(self):
        # Create data with clear swing highs/lows
        closes = [10, 15, 20, 15, 10, 15, 20, 15, 10, 15]
        highs = [c + 1 for c in closes]
        lows = [c - 1 for c in closes]
        result = compute_pivot_points(highs, lows, closes)
        assert "swing_highs" in result
        assert "swing_lows" in result
        assert 0 <= result["score"] <= 100

    def test_insufficient_data_raises(self):
        with pytest.raises(ValidationError, match="Pivot Points requires"):
            compute_pivot_points([1, 2], [0, 1], [0.5, 1.5])


# ---------------------------------------------------------------------------
# EMA Cross
# ---------------------------------------------------------------------------

class TestComputeEMACross:
    def test_bullish_signal(self):
        # Rising prices → short EMA > long EMA → bullish
        closes = _rising_closes(60, step=2)
        result = compute_ema_cross(closes, short_period=20, long_period=50)
        assert result["signal"] == "bullish"
        assert result["short_ema"] > result["long_ema"]

    def test_bearish_signal(self):
        # Falling prices → short EMA < long EMA → bearish
        closes = list(reversed(_rising_closes(60, step=2)))
        result = compute_ema_cross(closes, short_period=20, long_period=50)
        assert result["signal"] == "bearish"
        assert result["short_ema"] < result["long_ema"]

    def test_neutral_signal(self):
        # Flat prices → EMAs converge → neutral
        closes = _flat_closes(60)
        result = compute_ema_cross(closes, short_period=20, long_period=50)
        assert result["signal"] == "neutral"

    def test_insufficient_data_raises(self):
        closes = _rising_closes(30)
        with pytest.raises(ValidationError, match="EMA Cross requires"):
            compute_ema_cross(closes, short_period=20, long_period=50)