from __future__ import annotations

from dataclasses import dataclass, field
from typing import Any


@dataclass(eq=False)
class StapleState:
    sequence_tokens: list[str]
    anchor_pair: tuple[int, int] | None = None
    block_id: str | None = None
    topology: str = "linear"
    metadata: dict[str, Any] = field(default_factory=dict)

    @classmethod
    def from_sequence(cls, seq: str, **kwargs: Any) -> "StapleState":
        return cls(sequence_tokens=list(seq), **kwargs)

    def to_sequence(self) -> str:
        return "".join(self.sequence_tokens)

    def copy(self) -> "StapleState":
        return StapleState(
            sequence_tokens=self.sequence_tokens.copy(),
            anchor_pair=None if self.anchor_pair is None else tuple(self.anchor_pair),
            block_id=self.block_id,
            topology=self.topology,
            metadata=dict(self.metadata),
        )

    def __hash__(self) -> int:
        return hash((tuple(self.sequence_tokens), self.anchor_pair, self.block_id, self.topology))

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, StapleState):
            return False
        return (
            self.sequence_tokens == other.sequence_tokens
            and self.anchor_pair == other.anchor_pair
            and self.block_id == other.block_id
            and self.topology == other.topology
        )

    def __str__(self) -> str:
        return f"StapleState(seq={self.to_sequence()}, anchor={self.anchor_pair}, block={self.block_id}, topo={self.topology})"