"""Duration-normalized musical evaluation, independent of search/notation chunks."""
from __future__ import annotations

import fractions

import generator.solo.policy
import generator.solo.types

def passages(plan):
  if plan.passages:
    return plan.passages
  end = plan.end - plan.release
  active = (generator.solo.types.ActivitySpan(plan.start, end, 'active', plan.activity, fractions.Fraction(3, 4)),) if end > plan.start else ()
  return active + ((generator.solo.types.ActivitySpan(end, plan.end, 'space', fractions.Fraction(), fractions.Fraction()),) if plan.release else ())

def intervals(choices, start, end):
  return tuple((max(start, c.span.start), min(end, c.span.end)) for c in choices if c.scale and c.span.start < end and c.span.end > start)

def overlap(start, end, intervals):
  return sum((max(0, min(end, b) - max(start, a)) for a, b in intervals), fractions.Fraction())

def corridor(pitch, low, high):
  return max(low - pitch, 0, pitch - high)

def motif_fidelity(notes, motif, treatment):
  if treatment in ('quote', 'exact_quote'):
    return 0.0
  if treatment == 'rhythmic_reference':
    return 1.0 if len(notes) < min(2, len(motif.notes)) else 0.0
  actual = tuple(b.pitch.number() - a.pitch.number() for a, b in zip(notes, notes[1:]))
  expected = motif.contour()
  if not actual or not expected:
    return 0.0 if len(notes) == len(motif.notes) == 1 else 1.0
  count = min(2, len(actual), len(expected)) if treatment == 'opening_reference' else max(1, len(actual) // 2) if treatment == 'answer' else len(actual)
  errors = []
  for index in range(count):
    reference = expected[min(len(expected) - 1, index * len(expected) // max(1, len(actual)))]
    motion = actual[index]
    direction = ((reference > 0) - (reference < 0)) != ((motion > 0) - (motion < 0))
    errors.append(0.75 * direction + 0.25 * min(1, abs(motion - reference) / 12))
  evidence = min(2, len(expected))
  return max(sum(errors) / len(errors), max(0, evidence - len(actual)) / evidence)

class Evaluation:
  """Prepare fixed harmonic windows once; only soft penalties use float time."""
  def __init__(self, plan, choices, until=None):
    self.plan = plan
    self.until = plan.end if until is None else until
    self.duration = max(float(self.until - plan.start), 0.001)
    self.windows = []
    self.required = []
    for passage in passages(plan):
      end = min(passage.end, self.until)
      if end <= passage.start:
        continue
      active = intervals(choices, passage.start, end)
      length = float(sum((b - a for a, b in active), fractions.Fraction()))
      if length:
        self.windows.append((float(passage.start), float(end), tuple((float(a), float(b)) for a, b in active), length, float(passage.activity) * length, float(passage.occupancy), 0.5 if self.until < passage.end else 0))
      if passage.end <= self.until:
        protected = plan.treatment in ('quote', 'exact_quote', 'rhythmic_reference') and passage.end <= plan.start + plan.motif.duration
        authored_silence = protected and not any(overlap(plan.start + n.start, plan.start + n.end, active) for n in plan.motif.notes)
        self.required.append((passage, active, authored_silence))
    self.landmarks = tuple((float(p.earliest), float(p.latest), p.low, p.high, p.direction) for p in plan.landmarks if p.latest <= self.until)
  def feasible(self, notes):
    # Hard silence/space requirements retain exact rational boundaries.
    for passage, active, authored_silence in self.required:
      if passage.intent == 'space':
        if any(n.start < passage.end and n.end > passage.start for n in notes):
          return False
      elif active and not authored_silence and not any(n.start < b and n.end > a for n in notes for a, b in active):
        return False
    return True
  def features(self, notes, *, previous=None, movement=0):
    notes = generator.solo.types.sounding_notes(notes)
    sounded = tuple((float(n.start), float(n.end), n.pitch.number()) for n in notes)
    activity, occupancy = 0.0, 0.0
    for start, end, active, length, expected, occupied_goal, tolerance in self.windows:
      attacks = sum(start <= a < end and any(x <= a < y for x, y in active) for a, _, _ in sounded)
      occupied = sum(max(0, min(b, y) - max(a, x)) for a, b, _ in sounded for x, y in active)
      deviation = max(0, abs(attacks - expected) - tolerance)
      activity += length * min(1, deviation / max(1, expected))
      occupancy += length * abs(occupied / length - occupied_goal)
    start, end = float(self.plan.start), float(self.until)
    durations = [max(0, min(b, end) - max(a, start)) for a, b, _ in sounded]
    register = sum(length * min(1, corridor(pitch, *self.plan.register) / 12) for (_, _, pitch), length in zip(sounded, durations)) / max(sum(durations), 0.001)
    motions = [b[2] - a[2] for a, b in zip(sounded, sounded[1:])]
    contour = sum(min(1, max(0, abs(m) - 5) / 12) for m in motions) / max(1, len(motions))
    repetition = sum(a == b == 0 for a, b in zip(motions, motions[1:])) / max(1, len(motions) - 1)
    landmarks = []
    for earliest, latest, low, high, direction in self.landmarks:
      prior = next((n for n in reversed(sounded) if n[0] < earliest), None)
      landmarks.append(min((0.75 * min(1, corridor(n[2], low, high) / 12) + 0.25 * bool(prior and direction and (n[2] - prior[2]) * direction <= 0) for n in sounded if earliest <= n[0] <= latest), default=1))
    motif_notes = tuple(n for n in notes if n.role in ('motif', 'quote'))
    connection = min(1, abs(sounded[0][2] - previous.pitch.number()) / 12) if sounded and previous else 0
    return {'activity': activity / self.duration, 'occupancy': occupancy / self.duration, 'register': register, 'contour': contour, 'repetition': repetition, 'landmarks': sum(landmarks) / max(1, len(landmarks)), 'connection': connection, 'movement': min(1, movement / max(1, len(notes)) / 2000), 'fidelity': motif_fidelity(motif_notes, self.plan.motif, self.plan.treatment) if motif_notes else 0}

def features(plan, notes, choices, *, until=None, previous=None, movement=0):
  return Evaluation(plan, choices, until).features(notes, previous=previous, movement=movement)

def value(features):
  return sum(weight * features.get(name, 0) for name, weight in generator.solo.policy.DEFAULT.weights)

def feasible(plan, notes, choices, until):
  return Evaluation(plan, choices, until).feasible(notes)