from fastapi import APIRouter
from pydantic import BaseModel

from app.indicators.indicator_manager import IndicatorManager

router = APIRouter(
    prefix="/indicator",
    tags=["Indicator"]
)


class EMARequest(BaseModel):
    prices: list[float]
    period: int


class RSIRequest(BaseModel):
    prices: list[float]
    period: int = 14


class MACDRequest(BaseModel):
    prices: list[float]
    fast_period: int = 12
    slow_period: int = 26


@router.post("/ema")
def calculate_ema(request: EMARequest):

    result = IndicatorManager.calculate_ema(
        request.prices,
        request.period
    )

    return {
        "ema": result
    }


@router.post("/rsi")
def calculate_rsi(request: RSIRequest):

    result = IndicatorManager.calculate_rsi(
        request.prices,
        request.period
    )

    return {
        "rsi": result
    }


@router.post("/macd")
def calculate_macd(request: MACDRequest):

    result = IndicatorManager.calculate_macd(
        request.prices,
        request.fast_period,
        request.slow_period
    )

    return {
        "macd": result
    }
class SMARequest(BaseModel):
    prices: list[float]
    period: int


class ATRRequest(BaseModel):
    data: list[dict]
    period: int = 14


class BollingerRequest(BaseModel):
    prices: list[float]
    period: int = 20
    std_dev: float = 2.0


class SuperTrendRequest(BaseModel):
    data: list[dict]
    period: int = 10
    multiplier: float = 3.0


class VWAPRequest(BaseModel):
    data: list[dict]
@router.post("/sma")
def calculate_sma(request: SMARequest):

    result = IndicatorManager.calculate_sma(
        request.prices,
        request.period
    )

    return {
        "sma": result
    }


@router.post("/atr")
def calculate_atr(request: ATRRequest):

    result = IndicatorManager.calculate_atr(
        request.data,
        request.period
    )

    return {
        "atr": result
    }


@router.post("/bollinger")
def calculate_bollinger(request: BollingerRequest):

    result = IndicatorManager.calculate_bollinger(
        request.prices,
        request.period,
        request.std_dev
    )

    return result


@router.post("/supertrend")
def calculate_supertrend(request: SuperTrendRequest):

    result = IndicatorManager.calculate_supertrend(
        request.data,
        request.period,
        request.multiplier
    )

    return result


@router.post("/vwap")
def calculate_vwap(request: VWAPRequest):

    result = IndicatorManager.calculate_vwap(
        request.data
    )

    return {
        "vwap": result
    }