from __future__ import annotations
from abc import ABC, abstractmethod
import collections.abc
import json
from pathlib import Path
import typing
from typing import *

class Challenge[P, S, V](ABC):

    @abstractmethod
    def generate(self, seed: int) -> tuple[P, V]:
        raise NotImplementedError()

    @abstractmethod
    def verify(self, problem: P, solution: S, secrets: V) -> bool:
        raise NotImplementedError()

class Solver[P, S](ABC):

    @abstractmethod
    def solve(self, problem: P) -> S:
        raise NotImplementedError()

def _is_callable_hint(ty: Any) -> bool:
    return typing.get_origin(ty) is collections.abc.Callable or ty is collections.abc.Callable

def _is_serde(ty: type) -> bool:
    return isinstance(ty, type) and issubclass(ty, Serde) and (ty is not Serde)

def _convert_from(val: Any, ty: Any) -> Any:
    if ty is Any:
        return val
    origin = typing.get_origin(ty)
    args = typing.get_args(ty)
    if origin is Union:
        if val is None and type(None) in args:
            return None
        for variant in args:
            if variant is type(None):
                continue
            try:
                return _convert_from(val, variant)
            except (TypeError, KeyError):
                continue
        raise TypeError(f'value {val!r} does not match any variant of {ty}')
    if origin is list:
        if not isinstance(val, list):
            raise TypeError(f'expected list, got {type(val)}')
        if args:
            return [_convert_from(item, args[0]) for item in val]
        return val
    if origin is dict:
        if not isinstance(val, dict):
            raise TypeError(f'expected dict, got {type(val)}')
        if len(args) == 2:
            return {_convert_from(k, args[0]): _convert_from(v, args[1]) for k, v in val.items()}
        return val
    if origin is tuple:
        if not isinstance(val, (list, tuple)):
            raise TypeError(f'expected tuple, got {type(val)}')
        if args:
            return tuple((_convert_from(item, a) for item, a in zip(val, args)))
        return tuple(val)
    if _is_serde(ty):
        if isinstance(val, ty):
            return val
        if isinstance(val, dict):
            return ty.from_dict(val)
        raise TypeError(f'expected dict or {ty.__name__}, got {type(val)}')
    if isinstance(ty, type) and (not isinstance(val, ty)):
        raise TypeError(f'expected type `{ty.__name__}` but got `{type(val).__name__}`')
    return val

def _convert_to(val: Any) -> Any:
    if isinstance(val, Serde):
        return val.to_dict()
    if isinstance(val, list):
        return [_convert_to(item) for item in val]
    if isinstance(val, dict):
        return {k: _convert_to(v) for k, v in val.items()}
    if isinstance(val, tuple):
        return [_convert_to(item) for item in val]
    return val

class Serde:

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> Self:
        hints = typing.get_type_hints(cls)
        defaults = {key: val for key in dir(cls) if not key.startswith('__') and (not isinstance((val := getattr(cls, key)), Callable))}
        args = list()
        for key, ty in hints.items():
            if _is_callable_hint(ty):
                continue
            if key in data:
                val = data[key]
            elif key in defaults:
                val = defaults[key]
            else:
                raise KeyError(f"missing expected key '{key}'")
            args.append(_convert_from(val, ty))
        return cls(*args)

    def to_dict(self) -> dict[str, Any]:
        hints = typing.get_type_hints(type(self))
        result = {}
        for key, ty in hints.items():
            if _is_callable_hint(ty):
                continue
            result[key] = _convert_to(getattr(self, key))
        return result

    @classmethod
    def from_json(cls, json_str: str) -> Self:
        return cls.from_dict(json.loads(json_str))

    def to_json(self) -> str:
        return json.dumps(self.to_dict())

    @classmethod
    def from_json_file(cls, json_file: Path) -> Self:
        with json_file.open('r') as infile:
            return cls.from_dict(json.load(infile))

    def to_json_file(self, out: Path) -> None:
        with out.open('w') as outfile:
            json.dump(self.to_dict(), outfile)