"""Exact canonical rational numbers used by interval-event certificates."""
from __future__ import annotations

from dataclasses import dataclass
from fractions import Fraction
from math import gcd
from typing import Any


@dataclass(frozen=True, slots=True)
class Q:
    numerator: int
    denominator: int = 1

    def __post_init__(self) -> None:
        n = int(self.numerator)
        d = int(self.denominator)
        if d == 0:
            raise ValueError("rational denominator must be nonzero")
        if d < 0:
            n, d = -n, -d
        g = gcd(abs(n), d)
        object.__setattr__(self, "numerator", n // g)
        object.__setattr__(self, "denominator", d // g)

    @classmethod
    def from_value(cls, value: Any) -> "Q":
        if isinstance(value, cls):
            return value
        if isinstance(value, Fraction):
            return cls(value.numerator, value.denominator)
        if isinstance(value, bool):
            return cls(int(value), 1)
        if isinstance(value, int):
            return cls(value, 1)
        if isinstance(value, str):
            text = value.strip()
            if "/" in text:
                left, right = text.split("/", 1)
                return cls(int(left, 0), int(right, 0))
            return cls(int(text, 0), 1)
        if isinstance(value, dict):
            if set(value) >= {"num", "den"}:
                return cls(int(value["num"]), int(value["den"]))
            if set(value) >= {"numerator", "denominator"}:
                return cls(int(value["numerator"]), int(value["denominator"]))
        raise TypeError(f"cannot convert {type(value).__name__} to Q")

    def as_fraction(self) -> Fraction:
        return Fraction(self.numerator, self.denominator)

    def to_record(self) -> dict[str, int]:
        return {"num": self.numerator, "den": self.denominator}

    def to_text(self) -> str:
        if self.denominator == 1:
            return str(self.numerator)
        return f"{self.numerator}/{self.denominator}"

    def sign(self) -> int:
        return (self.numerator > 0) - (self.numerator < 0)

    def is_integer(self) -> bool:
        return self.denominator == 1

    def as_integer(self) -> int:
        if self.denominator != 1:
            raise ValueError(f"{self.to_text()} is not an integer")
        return self.numerator

    def floor(self) -> int:
        return self.numerator // self.denominator

    def ceil(self) -> int:
        return -((-self.numerator) // self.denominator)

    def __neg__(self) -> "Q":
        return Q(-self.numerator, self.denominator)

    def __abs__(self) -> "Q":
        return Q(abs(self.numerator), self.denominator)

    def __add__(self, other: Any) -> "Q":
        b = Q.from_value(other)
        return Q(self.numerator * b.denominator + b.numerator * self.denominator,
                 self.denominator * b.denominator)

    def __radd__(self, other: Any) -> "Q":
        return self + other

    def __sub__(self, other: Any) -> "Q":
        return self + (-Q.from_value(other))

    def __rsub__(self, other: Any) -> "Q":
        return Q.from_value(other) - self

    def __mul__(self, other: Any) -> "Q":
        b = Q.from_value(other)
        return Q(self.numerator * b.numerator, self.denominator * b.denominator)

    def __rmul__(self, other: Any) -> "Q":
        return self * other

    def __truediv__(self, other: Any) -> "Q":
        b = Q.from_value(other)
        if b.numerator == 0:
            raise ZeroDivisionError("rational division by zero")
        return Q(self.numerator * b.denominator, self.denominator * b.numerator)

    def __rtruediv__(self, other: Any) -> "Q":
        return Q.from_value(other) / self

    def __lt__(self, other: Any) -> bool:
        b = Q.from_value(other)
        return self.numerator * b.denominator < b.numerator * self.denominator

    def __le__(self, other: Any) -> bool:
        return self == Q.from_value(other) or self < other

    def __gt__(self, other: Any) -> bool:
        return not self <= other

    def __ge__(self, other: Any) -> bool:
        return not self < other

    def __int__(self) -> int:
        return self.as_integer()

    def __str__(self) -> str:
        return self.to_text()