"""Candidate tracking and a frequency/positional heuristic for ranking guesses."""

from collections import Counter
from dataclasses import dataclass, field

from .game import Clue, score_guess

WORD_LEN = 5
MAX_GUESSES = 6


@dataclass
class GuessRecord:
    guess: str
    pattern: tuple


@dataclass
class Solver:
    answers: list
    extra_guesses: list
    history: list = field(default_factory=list)
    candidates: list = field(init=False)

    def __post_init__(self):
        self.candidates = list(self.answers)

    @property
    def all_words(self) -> list:
        return self.answers + self.extra_guesses

    def apply(self, guess: str, pattern: tuple) -> None:
        """Record a guess/result and narrow the remaining candidates to those
        consistent with it (by literally re-simulating Wordle's own coloring)."""
        guess = guess.lower()
        self.history.append(GuessRecord(guess, pattern))
        self.candidates = [w for w in self.candidates if score_guess(guess, w) == pattern]

    def reset(self) -> None:
        self.history.clear()
        self.candidates = list(self.answers)

    def is_solved(self) -> bool:
        return bool(self.history) and self.history[-1].pattern == (Clue.GREEN,) * WORD_LEN

    def hard_mode_constraints(self):
        """Derive the two hard-mode requirements from history so far:
        fixed green letters by position, and minimum required count per
        letter from any green/yellow marks seen."""
        green = {}
        min_count = Counter()
        for rec in self.history:
            marks_this_guess = Counter()
            for i, (ch, clue) in enumerate(zip(rec.guess, rec.pattern)):
                if clue == Clue.GREEN:
                    green[i] = ch
                    marks_this_guess[ch] += 1
                elif clue == Clue.YELLOW:
                    marks_this_guess[ch] += 1
            for ch, count in marks_this_guess.items():
                if count > min_count[ch]:
                    min_count[ch] = count
        return green, min_count

    def hard_mode_pool(self) -> list:
        """Every known word that is a *legal* next guess under hard-mode rules:
        green letters stay in place, and every yellow/green letter seen so far
        appears at least as many times as it has been confirmed."""
        if not self.history:
            return list(self.all_words)

        green, min_count = self.hard_mode_constraints()
        pool = []
        for w in self.all_words:
            if any(w[i] != ch for i, ch in green.items()):
                continue
            counts = Counter(w)
            if any(counts[ch] < need for ch, need in min_count.items()):
                continue
            pool.append(w)
        return pool


def letter_stats(words: list):
    """Per-position and overall-presence letter frequencies across `words`."""
    n = len(words)
    position_freq = [Counter() for _ in range(WORD_LEN)]
    presence_freq = Counter()
    for w in words:
        for i, ch in enumerate(w):
            position_freq[i][ch] += 1
        for ch in set(w):
            presence_freq[ch] += 1
    position_freq = [{ch: c / n for ch, c in pf.items()} for pf in position_freq]
    presence_freq = {ch: c / n for ch, c in presence_freq.items()}
    return position_freq, presence_freq


def score_word(word, position_freq, presence_freq, position_weight=1.0, presence_weight=1.0, repeat_penalty=0.85):
    """Higher score = letters that are both common overall and likely in this
    position, favoring new letters over repeats since repeats teach us less."""
    score = 0.0
    seen = set()
    for i, ch in enumerate(word):
        score += position_weight * position_freq[i].get(ch, 0.0)
        gain = presence_weight * presence_freq.get(ch, 0.0)
        score += gain if ch not in seen else -repeat_penalty * gain
        seen.add(ch)
    return score


def rank_guesses(pool, candidates, top_n=10, position_weight=1.0, presence_weight=1.0):
    """Rank `pool` words by the heuristic, computed from letter stats over the
    still-possible `candidates`. Returns (word, score, is_possible_answer)."""
    position_freq, presence_freq = letter_stats(candidates)
    candidate_set = set(candidates)
    scored = [
        (score_word(w, position_freq, presence_freq, position_weight, presence_weight), w)
        for w in pool
    ]
    scored.sort(key=lambda pair: (-pair[0], pair[1]))
    return [(w, s, w in candidate_set) for s, w in scored[:top_n]]