"""Online and reference memory-writing algorithms for OracleMem."""

from __future__ import annotations

from .objective import candidate_maps, coverage_utility, marginal_gain, selected_cost, unit_weights
from .schema import CandidateMemory, Instance, SolverResult
from .solvers import _result


def greedy_reference(instance: Instance, budget: int) -> SolverResult:
  weights = unit_weights(instance)
  remaining = list(instance.candidates)
  selected: list[CandidateMemory] = []
  used_exp: set[str] = set()
  while True:
    best = None
    best_density = 0.0
    for candidate in remaining:
      if candidate.experience_id in used_exp:
        continue
      if selected_cost(selected) + candidate.cost > budget:
        continue
      gain = marginal_gain(selected, candidate, weights)
      density = gain / max(candidate.cost, 1)
      if density > best_density:
        best_density = density
        best = candidate
    if best is None:
      break
    selected.append(best)
    used_exp.add(best.experience_id)
  return _result("greedy_reference", budget, selected, weights)


def recency_raw(instance: Instance, budget: int) -> SolverResult:
  weights = unit_weights(instance)
  _, by_exp = candidate_maps(instance)
  selected: list[CandidateMemory] = []
  cost = 0
  for experience in reversed(instance.experiences):
    raw = [c for c in by_exp.get(experience.experience_id, []) if c.representation == "raw"]
    if not raw:
      continue
    candidate = raw[0]
    if cost + candidate.cost <= budget:
      selected.append(candidate)
      cost += candidate.cost
  selected.reverse()
  return _result("recency_raw", budget, selected, weights)


def no_tombstone_greedy(instance: Instance, budget: int) -> SolverResult:
  filtered = tuple(
      candidate for candidate in instance.candidates
      if candidate.representation not in {"tombstone", "compound_update"}
  )
  filtered_instance = type(instance)(
      instance_id=instance.instance_id,
      seed=instance.seed,
      units=instance.units,
      experiences=instance.experiences,
      candidates=filtered,
      queries=instance.queries,
      metadata=instance.metadata,
  )
  result = greedy_reference(filtered_instance, budget)
  return SolverResult("no_tombstone_greedy", budget, result.selected_ids, result.utility, result.cost)


def density_only(instance: Instance, budget: int) -> SolverResult:
  weights = unit_weights(instance)
  _, by_exp = candidate_maps(instance)
  selected: list[CandidateMemory] = []
  cost = 0
  for experience in instance.experiences:
    best = None
    best_density = 0.0
    for candidate in by_exp.get(experience.experience_id, []):
      if cost + candidate.cost > budget:
        continue
      gain = marginal_gain(selected, candidate, weights)
      density = gain / max(candidate.cost, 1)
      if density > best_density:
        best = candidate
        best_density = density
    if best is not None:
      selected.append(best)
      cost += best.cost
  return _result("density_only", budget, selected, weights)


def grouped_value_threshold(instance: Instance, budget: int, threshold: float) -> SolverResult:
  weights = unit_weights(instance)
  _, by_exp = candidate_maps(instance)
  selected: list[CandidateMemory] = []
  cost = 0
  for experience in instance.experiences:
    admissible: list[tuple[float, CandidateMemory]] = []
    for candidate in by_exp.get(experience.experience_id, []):
      if cost + candidate.cost > budget:
        continue
      gain = marginal_gain(selected, candidate, weights)
      density = gain / max(candidate.cost, 1)
      if density >= threshold and gain > 0:
        admissible.append((gain, candidate))
    if admissible:
      _, chosen = max(admissible, key=lambda item: (item[0], -item[1].cost))
      selected.append(chosen)
      cost += chosen.cost
  return _result(f"gvt_threshold_{threshold:.4g}", budget, selected, weights)


def grouped_value_threshold_grid(instance: Instance, budget: int) -> SolverResult:
  weights = unit_weights(instance)
  densities = []
  for candidate in instance.candidates:
    gain = coverage_utility([candidate], weights)
    if gain > 0:
      densities.append(gain / max(candidate.cost, 1))
  if not densities:
    return SolverResult("gvt_grid", budget, tuple(), 0.0, 0)
  thresholds = sorted(set([0.0, *densities]))
  best = None
  for threshold in thresholds:
    result = grouped_value_threshold(instance, budget, threshold)
    if best is None or result.utility > best.utility:
      best = result
  assert best is not None
  return SolverResult("gvt_grid", budget, best.selected_ids, best.utility, best.cost)