from dataclasses import dataclass


@dataclass(slots=True)
class ReframrConfig:
    embedding_dim: int = 16
    state_dim: int = 32
    timescales: tuple[float, ...] = (1.0, 0.5, 0.25, 0.125)
    window_size: int = 2
    regularization: float = 1e-3
    min_frequency: int = 1
    max_vocab: int | None = 256
    tokenizer_vocab_size: int = 256
    tokenizer_min_pair_frequency: int = 2
    max_training_examples: int | None = 60000
    max_memory_examples: int | None = None
    max_state_tokens_per_document: int | None = 768
    max_transition_contexts_per_order: int | None = 4096
    max_transition_next_tokens: int = 4
    lowercase: bool = False
    default_reasoning_profile: str = "none"
    layout_profile: str = "rfm-base"
    effective_parameter_target: int = 0

    def to_dict(self) -> dict[str, object]:
        return {
            "embedding_dim": self.embedding_dim,
            "state_dim": self.state_dim,
            "timescales": list(self.timescales),
            "window_size": self.window_size,
            "regularization": self.regularization,
            "min_frequency": self.min_frequency,
            "max_vocab": self.max_vocab,
            "tokenizer_vocab_size": self.tokenizer_vocab_size,
            "tokenizer_min_pair_frequency": self.tokenizer_min_pair_frequency,
            "max_training_examples": self.max_training_examples,
            "max_memory_examples": self.max_memory_examples,
            "max_state_tokens_per_document": self.max_state_tokens_per_document,
            "max_transition_contexts_per_order": self.max_transition_contexts_per_order,
            "max_transition_next_tokens": self.max_transition_next_tokens,
            "lowercase": self.lowercase,
            "default_reasoning_profile": self.default_reasoning_profile,
            "layout_profile": self.layout_profile,
            "effective_parameter_target": self.effective_parameter_target,
        }

    @classmethod
    def from_dict(cls, payload: dict[str, object]) -> "ReframrConfig":
        return cls(
            embedding_dim=int(payload["embedding_dim"]),
            state_dim=int(payload["state_dim"]),
            timescales=tuple(float(value) for value in payload["timescales"]),
            window_size=int(payload["window_size"]),
            regularization=float(payload["regularization"]),
            min_frequency=int(payload["min_frequency"]),
            max_vocab=(
                int(payload.get("max_vocab", 256))
                if payload.get("max_vocab", 256) is not None
                else None
            ),
            tokenizer_vocab_size=int(payload.get("tokenizer_vocab_size", 256)),
            tokenizer_min_pair_frequency=int(payload.get("tokenizer_min_pair_frequency", 2)),
            max_training_examples=(
                int(payload["max_training_examples"])
                if payload.get("max_training_examples") is not None
                else None
            ),
            max_memory_examples=(
                int(payload["max_memory_examples"])
                if payload.get("max_memory_examples") is not None
                else None
            ),
            max_state_tokens_per_document=(
                int(payload["max_state_tokens_per_document"])
                if payload.get("max_state_tokens_per_document") is not None
                else 768
            ),
            max_transition_contexts_per_order=(
                int(payload["max_transition_contexts_per_order"])
                if payload.get("max_transition_contexts_per_order") is not None
                else None
            ),
            max_transition_next_tokens=int(payload.get("max_transition_next_tokens", 4)),
            lowercase=bool(payload.get("lowercase", False)),
            default_reasoning_profile=str(payload.get("default_reasoning_profile", "none")),
            layout_profile=str(payload.get("layout_profile", "rfm-base")),
            effective_parameter_target=int(payload.get("effective_parameter_target", 0)),
        )