"""PRISK-Zeile: Felder + Berechnungen. Alles andere erbt Row."""
from __future__ import annotations

from dataclasses import dataclass, field

from ...row.row import Row

try:
    from scipy.stats import beta as beta_dist
except ImportError:
    beta_dist = None


@dataclass
class PriskRow(Row):
    inputColumns = (
        "AssetNr",
        "RiskNr",
        "Hazard",
        "Rational",
        "Type",
        "Probability",
        "Min",
        "Mod",
        "Max",
    )
    computedColumns = (
        "K",
        "Alpha",
        "Beta",
        "RiskValue",
    )

    AssetNr: str = None
    RiskNr: str = None
    Hazard: str = None
    Rational: str = None
    Type: str = None
    Probability: float = None
    Min: float = None
    Mod: float = None
    Max: float = None
    Alpha: float = None
    Beta: float = None
    RiskValue: float = None
    K: float = field(init=False, repr=False, default=0.0)
    test_u: float = field(init=False, repr=False, default=0.0)

    def __post_init__(self) -> None:
        self.K = self.setting_float("BETA_K", 0.0)
        self.test_u = self.setting_float("TEST_U", 0.0)

    def getK(self) -> float:
        return self.K

    def _value_range(self) -> float:
        return self.Max - self.Min

    def getAlpha(self) -> float:
        try:
            span = self._value_range()
            if span == 0:
                self.Alpha = 0.0
                return self.Alpha
            self.Alpha = self.K * (self.Mod - self.Min) / span + 1
            return self.Alpha
        except (TypeError, ValueError):
            self.Alpha = 0.0
            return self.Alpha

    def getBeta(self) -> float:
        try:
            span = self._value_range()
            if span == 0:
                self.Beta = 0.0
                return self.Beta
            self.Beta = self.K * (self.Max - self.Mod) / span + 1
            return self.Beta
        except (TypeError, ValueError):
            self.Beta = 0.0
            return self.Beta

    def getRiskValue(self, u: float | None = None) -> float:
    
        eff = self.test_u if u is None else u
        if beta_dist is None:
            raise ValueError("scipy fehlt. Installiere es mit: pip install scipy")
        if not 0 <= eff <= 1:
            raise ValueError("u muss zwischen 0 und 1 liegen")

        alpha = self.Alpha if self.Alpha is not None else self.getAlpha()
        beta = self.Beta if self.Beta is not None else self.getBeta()
        if alpha <= 0 or beta <= 0:
            raise ValueError(f"Ungueltige Beta-Parameter: Alpha={alpha}, Beta={beta}")

        if eff == 0:
            out = float(self.Min)
        elif eff == 1:
            out = float(self.Max)
        else:
            out = self.Min + self._value_range() * float(beta_dist.ppf(eff, alpha, beta))

        if u is None:
            self.RiskValue = out
        return out