import abc
from typing import Any, Callable, NoReturn

# This file is not in any way related to the project,
# I just wanted to built Rust's error handling in python so here it is.


class Result[T: Any, E: Exception](abc.ABC):
    @abc.abstractmethod
    def expect(self, message: str) -> T | NoReturn: ...

    @abc.abstractmethod
    def unwrap(self) -> T | NoReturn: ...

    @abc.abstractmethod
    def unwrap_or(self, value: T) -> T: ...

    @abc.abstractmethod
    def unwrap_or_else(self, func: Callable[..., T]) -> T: ...

    @abc.abstractmethod
    def unwrap_unchecked(self) -> T | E: ...

    @abc.abstractmethod
    def expect_err(self, message: str) -> E | NoReturn: ...

    @abc.abstractmethod
    def unwrap_err(self) -> E | NoReturn: ...

    @abc.abstractmethod
    def unwrap_err_unchecked(self) -> E | T: ...

    @abc.abstractmethod
    def is_err(self) -> bool: ...

    @abc.abstractmethod
    def is_ok(self) -> bool: ...

    def ok(self) -> T | None:
        if self.is_ok():
            return ~self
        return None

    def err(self) -> E | None:
        if self.is_err():
            return -self
        return None

    def transpose(self) -> "Result[T, E] | None":
        if self.is_ok() and self.ok() is None:
            return None
        return self

    def __invert__(self) -> T | NoReturn:
        return self.unwrap()

    def __neg__(self) -> E:
        return self.unwrap_err()

    def __and__(self, other: "Result") -> "Result[T, E]":
        return self if self.is_err() else other

    def __or__(self, other: "Result") -> "Result[T, E]":
        return self if self.is_ok() else other

    def __rshift__(self, func: Callable[..., "Result[T, E]"]) -> "Result[T, E]":
        if self.is_err():
            return self
        return func()

    def __floordiv__(self, func: Callable[..., "Result[T, E]"]) -> "Result[T, E]":
        if self.is_ok():
            return self
        return func()


class Ok[T: Any, E: Exception](Result[T, E]):
    __match_args__ = ("value",)
    value: Any

    def __init__(self, value: T):
        self.value = value

    def expect(self, message: str) -> T:
        return self.value

    def unwrap(self) -> T:
        return self.value

    def unwrap_or(self, value: T) -> T:
        return self.value

    def unwrap_or_else(self, func: Callable[[], T]) -> T:
        return self.value

    def unwrap_unchecked(self) -> T:
        return self.value

    def expect_err(self, message: str) -> NoReturn:
        raise RuntimeError(message)

    def unwrap_err(self) -> NoReturn:
        raise RuntimeError(self.value)

    def unwrap_err_unchecked(self) -> T:
        return self.value

    def is_err(self) -> bool:
        return False

    def is_ok(self) -> bool:
        return True

    def __repr__(self) -> str:
        return f"Ok({repr(self.value)})"


class Err[T: Any, E: Exception](Result[T, E]):
    __match_args__ = ("message",)
    message: E

    def __init__(self, message: E):
        self.message = message

    def expect(self, message: str) -> NoReturn:
        raise RuntimeError(message)

    def unwrap(self) -> NoReturn:
        raise self.message

    def unwrap_or(self, value: T) -> T:
        return value

    def unwrap_or_else(self, func: Callable[[], T]) -> T:
        return func()

    def unwrap_unchecked(self) -> E:
        return self.message

    def expect_err(self, message: str) -> E:
        return self.message

    def unwrap_err(self) -> E:
        return self.message

    def unwrap_err_unchecked(self) -> E:
        return self.message

    def is_ok(self) -> bool:
        return False

    def is_err(self) -> bool:
        return True

    def __repr__(self) -> str:
        return f"Err({repr(self.message)})"


result_a = Ok(10)
result_b = Err(Exception("hello"))

match result_b:
    case Ok(result):
        print("+", result)
    case Err(error):
        print("-", error)

print(result_a & result_b)