"""Typed, target-driven harmonic expression against written harmony and explicit musical relationships."""
from __future__ import annotations
import dataclasses
import fractions
import functools

import generator.harmony
import generator.model
import generator.pitch
import generator.solo.types
import generator.vocabulary

@functools.lru_cache(maxsize=512)
def parsed_chord(symbol):
  """Private read-only chord analysis shared by pure expression operations."""
  return generator.harmony.parse_symbol(symbol)

@functools.lru_cache(maxsize=512)
def degree_spelling(letter, accidental, degree, alter):
  root = {'letter': letter, 'alter': generator.model.rational(accidental), 'octave': 4}
  p = generator.pitch.shift_pitch(root, degree - 1, generator.harmony.degree_semitones(degree, alter))
  return generator.solo.types.Pitch(p['letter'], generator.model.alteration(p['alter']), p['octave'])

def quality(chord):
  degrees = generator.harmony.degrees(chord)
  if degrees.get(3) == 0 and degrees.get(7) == -1:
    return 'dominant'
  if degrees.get(3) == -1:
    if degrees.get(5) == -1:
      return 'half_diminished' if degrees.get(7) == -1 else 'diminished'
    return 'minor'
  if chord['kind'] in ('suspended-second', 'suspended-fourth'):
    return chord['kind']
  if degrees.get(3) == 0 and degrees.get(5) == 0:
    return 'major'
  return 'other'

def degree_pitch(chord, degree, alter, near):
  value = degree_spelling(chord['root']['letter'], generator.model.alteration(chord['root']['alter']), degree, alter)
  return dataclasses.replace(value, octave=value.octave + round((near - value.number()) / 12))

@functools.lru_cache(maxsize=1024)
def chromatic(target, delta):
  # Chromatic neighbors are spelled relative to their exact destination.
  if delta in (-3, -2, -1, 1, 2, 3):
    step = (1 if delta > 0 else -1) * (2 if abs(delta) == 3 else 1)
    root = {'letter': target.letter, 'alter': generator.model.rational(target.alter), 'octave': target.octave}
    p = generator.pitch.shift_pitch(root, step, delta)
    return generator.solo.types.Pitch(p['letter'], generator.model.alteration(p['alter']), p['octave'])
  raise ValueError('unsupported approach interval')

def eligible_color(rule, span, harmony):
  # An explicit no-chord span (or missing harmony) has no optional colors.
  # In particular, looking ahead for an anticipation must not try to parse
  # the display label N.C. as a written chord.
  if not span or span.chord == 'N.C.' or not span.chord:
    return False
  key = (tuple(rule['qualities']), rule['degree'], rule['alter'], rule.get('function'), span.start, span.end, span.chord)
  cache = harmony.color_eligibility
  if key not in cache:
    cache[key] = _eligible_color(rule, span, harmony)
  return cache[key]

def _eligible_color(rule, span, harmony):
  chord = parsed_chord(span.chord)
  degrees = generator.harmony.degrees(chord)
  if quality(chord) not in rule['qualities']:
    return False
  degree = rule['degree']
  simple = (degree - 1) % 7 + 1
  # Explicit alterations and omissions take precedence over optional colors.
  if any((d['value'] - 1) % 7 + 1 == simple and (d['type'] == 'subtract' or generator.model.alteration(d['alter']) != rule['alter']) for d in chord.get('degrees', [])):
    return False
  if degree in degrees and degrees[degree] != rule['alter']:
    return False
  following = next((s for s in harmony.spans if s.start >= span.end and s.chord != span.chord and s.chord != 'N.C.'), None)
  root = int(generator.model.NATURAL[chord['root']['letter']] + generator.model.alteration(chord['root']['alter'])) % 12
  next_chord = parsed_chord(following.chord) if following else None
  next_root = int(generator.model.NATURAL[next_chord['root']['letter']] + generator.model.alteration(next_chord['root']['alter'])) % 12 if next_chord else None
  function = rule.get('function')
  if function == 'predominant_to_dominant' and not (next_chord and quality(next_chord) == 'dominant' and (next_root - root) % 12 == 5):
    return False
  if function == 'resolving_dominant' and (next_root is None or (root - next_root) % 12 != 7):
    return False
  if function == 'tonic_or_predominant':
    tonic = span.key.get('tonic')
    if not tonic:
      return False
    tonic_pc = int(generator.model.NATURAL[tonic['letter']] + generator.model.alteration(tonic['alter'])) % 12
    if root != tonic_pc and not (next_chord and quality(next_chord) == 'dominant' and (next_root - root) % 12 == 5):
      return False
  return True

def validate(notes, contracts, harmony, *, composition=None):
  """Return event permissions only after checking complete actual gestures."""
  composition = composition or generator.vocabulary.current()
  actual = {n.event_id: n for n in notes}
  approved = {}

  def same(expected):
    n = actual.get(expected.event_id)
    return n and (n.start, n.end, n.pitch) == (expected.start, expected.end, expected.pitch)

  for c in contracts:
    if not c.events or not all(same(n) for n in (*c.events, c.target)):
      return {}, c.id + ': missing or changed expression event/target'
    if c.preparation and not same(c.preparation):
      return {}, c.id + ': changed preparation'
    if any(n.event_id in approved for n in c.events):
      return {}, c.id + ': overlapping expression permissions'
    target = c.target
    span = harmony.at(c.boundary if c.boundary is not None else c.events[0].start if c.kind == 'color' else target.start)
    if not span or span.chord == 'N.C.' or span.chord != c.chord:
      return {}, c.id + ': wrong target harmony'
    if c.kind in ('anticipation', 'anticipated_color'):
      previous = next((s for s in harmony.spans if s.end == c.boundary), None)
      if not previous or previous.chord.strip('()') == span.chord.strip('()'):
        return {}, c.id + ': anticipation requires a harmonic change'
    if c.kind in ('approach', 'enclosure', 'connection'):
      rule = next((r for r in composition.data('lead_ins')['patterns'] if r['id'] == c.rule and r['kind'] == c.kind), None)
      if not rule or len(c.events) != len(rule['semitones']):
        return {}, c.id + ': unknown approach formula'
      arrival = c.boundary if c.boundary is not None else target.start
      if c.boundary is not None and not any(a.kind == 'anticipation' and a.target == target and a.boundary == c.boundary for a in contracts):
        return {}, c.id + ': future target lacks anticipation contract'
      planned_color = any(a.kind == 'color' and a.target == target and a.events == (target,) for a in contracts)
      if not planned_color and (target.pitch.number() % 12 not in harmony.members(arrival, target.end) or target.pitch.number() % 12 not in harmony.permitted(arrival, target.end)):
        return {}, c.id + ': invalid destination hold'
      gaps = tuple(map(fractions.Fraction, rule.get('internal_gaps', ['0'] * (len(c.events) - 1))))
      if len(gaps) != len(c.events) - 1 or any(g < 0 for g in gaps):
        return {}, c.id + ': invalid internal approach gaps'
      gap = fractions.Fraction(rule['gap'])
      cursor = target.start - gap - sum((fractions.Fraction(d) for d in rule['durations']), fractions.Fraction()) - sum(gaps, fractions.Fraction())
      if target.start - cursor > fractions.Fraction(composition.data('lead_ins')['max_approach']):
        return {}, c.id + ': approach too long'
      for i, (n, step, duration) in enumerate(zip(c.events, rule['semitones'], rule['durations'])):
        if n.start != cursor or n.end != cursor + fractions.Fraction(duration) or n.pitch.number() != target.pitch.number() + step:
          return {}, c.id + ': wrong register, interval, or timing'
        cursor = n.end + (gaps[i] if i < len(gaps) else 0)
      for index in rule.get('diatonic_indices', []):
        n = c.events[index]
        if n.pitch.number() % 12 not in harmony.permitted(n.start, n.end):
          return {}, c.id + ': declared diatonic neighbor is outside source-key/chord motion'
      if any(n.start < c.target.start and n.end > c.events[0].start and n.event_id not in {e.event_id for e in c.events} for n in notes):
        return {}, c.id + ': interrupted approach'
      if c.kind == 'connection' and (not c.preparation or c.preparation.end != c.events[0].start or abs(c.preparation.pitch.number() - c.events[0].pitch.number()) > 2):
        return {}, c.id + ': chromatic connection lacks its incoming motion'
    elif c.kind == 'passing':
      rule = composition.data('lead_ins')['passing']
      if c.rule != rule['id'] or len(c.events) != 1 or not c.preparation:
        return {}, c.id + ': unsupported passing figure'
      n, = c.events
      before = c.preparation
      left = n.pitch.number() - before.pitch.number()
      right = target.pitch.number() - n.pitch.number()
      if before.end != n.start or n.end != target.start or n.end - n.start > fractions.Fraction(rule['max_note']) or left != right or left not in rule['steps']:
        return {}, c.id + ': interrupted/nonstepwise passing figure'

      def supported(endpoint):
        return harmony.ordinary(endpoint) or any(a.kind in ('color', 'anticipated_color') and endpoint in a.events for a in contracts)

      if not supported(before) or not supported(target):
        return {}, c.id + ': unsupported passing endpoints'
    elif c.kind == 'delayed_approach':
      rule = composition.data('lead_ins').get('delayed_approach', {})
      if c.rule != rule.get('id') or len(c.events) != 1:
        return {}, c.id + ': unknown delayed approach'
      n, = c.events
      if n.end - n.start > fractions.Fraction(rule['max_note']) or not n.end <= target.start <= n.start + fractions.Fraction(rule['deadline']):
        return {}, c.id + ': expired delayed approach'
      if target.pitch.number() - n.pitch.number() not in rule['steps']:
        return {}, c.id + ': wrong delayed target register'
      if target.pitch.number() % 12 not in harmony.members(target.start, target.end) or target.pitch.number() % 12 not in harmony.permitted(target.start, target.end):
        return {}, c.id + ': invalid delayed destination'
    elif c.kind == 'color':
      rule = next((r for r in composition.data('harmony')['colors'] if r['id'] == c.rule), None)
      if not rule:
        return {}, c.id + ': unknown color policy'
      colored = False
      for n in c.events:
        if n.end - n.start > fractions.Fraction(rule['max_beats']):
          return {}, c.id + ': excessive color duration'
        for region, a, b in harmony.segments(n):
          if n.pitch.number() % 12 in region.roles.basic | region.roles.specified:
            continue
          if region.chord == 'N.C.' or not eligible_color(rule, region, harmony):
            return {}, c.id + ': incompatible color harmony/function'
          p = degree_pitch(parsed_chord(region.chord), rule['degree'], rule['alter'], n.pitch.number())
          # The rule retains the functional degree/spelling. Encoded
          # enharmonic notation must not change sounding harmonic validity.
          if p.number() != n.pitch.number():
            return {}, c.id + ': color degree/register mismatch'
          colored = True
      if not colored:
        return {}, c.id + ': no interval expresses the declared color'
      last = c.events[-1]
      if rule.get('resolve'):
        if target.event_id == last.event_id or not 0 <= target.start - last.end <= fractions.Fraction(composition.data('harmony')['resolution_gap']) or not 0 < abs(target.pitch.number() - last.pitch.number()) <= 2 or target.pitch.number() % 12 not in harmony.members(target.start, target.end):
          return {}, c.id + ': unresolved color'
    elif c.kind == 'suspension':
      rule = next((r for r in composition.data('harmony').get('suspensions', []) if r['id'] == c.rule), None)
      if not rule or len(c.events) != 1 or c.boundary is None:
        return {}, c.id + ': unsupported suspension'
      held, = c.events
      if not held.start <= c.boundary - fractions.Fraction(rule['preparation']) < c.boundary < held.end:
        return {}, c.id + ': insufficient sounding preparation'
      if held.pitch.number() % 12 not in harmony.members(held.start, c.boundary):
        return {}, c.id + ': nonchordal preparation'
      if held.end - c.boundary > fractions.Fraction(rule['max_delay']) or target.start != held.end or target.pitch.number() - held.pitch.number() not in rule['steps']:
        return {}, c.id + ': missed suspension resolution'
      if target.pitch.number() % 12 not in harmony.members(target.start, target.end):
        return {}, c.id + ': invalid suspension target'
      if held.pitch.number() % 12 not in harmony.permitted(held.start, held.end):
        return {}, c.id + ': suspension outside source-key/chord motion'
    elif c.kind == 'anticipated_color':
      rule = next((r for r in composition.data('harmony')['colors'] if r['id'] == c.rule), None)
      if not rule or len(c.events) != 1 or c.boundary != span.start:
        return {}, c.id + ': unsupported anticipated color'
      n, = c.events
      if not n.start < c.boundary < n.end or c.boundary - n.start > fractions.Fraction(composition.data('harmony')['anticipation_max']):
        return {}, c.id + ': invalid anticipated color interval'
      arrived = dataclasses.replace(n, start=c.boundary)
      target = arrived if c.target == n else c.target
      inner = generator.solo.types.ExpressionContract(c.id + ':arrived', 'color', rule['id'], (arrived,), target, span.chord)
      _, error = validate((arrived, *((target,) if target != arrived else ())), (inner,), harmony, composition=composition)
      if error:
        return {}, error
    elif c.kind == 'anticipation':
      if c.rule not in ('early_chord_tone', 'early_reattack') or len(c.events) != 1 or span.start != c.boundary:
        return {}, c.id + ': unknown anticipation or non-boundary target'
      n, = c.events
      if c.boundary is None or not n.start < c.boundary or c.boundary - n.start > fractions.Fraction(composition.data('harmony')['anticipation_max']):
        return {}, c.id + ': invalid anticipation interval'
      if c.rule == 'early_chord_tone' and (n != target or not c.boundary < n.end):
        return {}, c.id + ': invalid held anticipation'
      if c.rule == 'early_reattack' and (n.end != c.boundary or target.start != c.boundary or target.event_id == n.event_id or target.pitch.number() != n.pitch.number()):
        return {}, c.id + ': invalid anticipated reattack'
      if target.pitch.number() % 12 not in harmony.members(c.boundary, target.end) or target.pitch.number() % 12 not in harmony.permitted(c.boundary, target.end):
        return {}, c.id + ': invalid future destination'
    elif c.kind == 'blues':
      if len(c.events) != 1:
        return {}, c.id + ': blues treatment requires one inflected event'
      rule = next((r for r in composition.data('lead_ins')['blues'] if r['id'] == c.rule), None)
      n, = c.events
      chord = parsed_chord(span.chord)
      if not rule or n.end - n.start > fractions.Fraction(1, 2) or n.end != target.start or target.pitch.number() % 12 not in span.roles.basic:
        return {}, c.id + ': unresolved blues inflection'
      expected = degree_pitch(chord, rule['degree'], rule['alter'], n.pitch.number())
      resolved = degree_pitch(chord, rule['target_degree'], 0, target.pitch.number())
      if n.pitch != expected or target.pitch != resolved or target.pitch.number() - n.pitch.number() != 1:
        return {}, c.id + ': unsupported blues destination'
      if not c.preparation or c.preparation.end != n.start or abs(c.preparation.pitch.number() - n.pitch.number()) > 2:
        return {}, c.id + ': unprepared blues gesture'
    else:
      return {}, c.id + ': unknown expression kind'
    for n in c.events:
      covered = n.start
      for region, a, b in harmony.segments(n):
        if a != covered or region.chord == 'N.C.':
          return {}, c.id + ': missing harmony'
        covered = b
      if covered != n.end:
        return {}, c.id + ': incomplete harmonic coverage'
      approved[n.event_id] = c
  return approved, ''

def validate_frontier(notes, contracts, harmony, until, complete, *, composition=None):
  """Validate heard prefixes and bounded future obligations separately.

  Future contract events are used ONLY to establish rule feasibility. They do
  not count as heard resolution; the contract stays pending until its entire
  target hold is present. Missing past events and expired deadlines fail.
  """
  composition = composition or generator.vocabulary.current()
  if complete:
    approved, error = validate(notes, contracts, harmony, composition=composition)
    return approved, (), error
  actual = {n.event_id: n for n in notes}
  future = dict(actual)
  pending = []
  for c in contracts:
    required = tuple(dict.fromkeys((*c.events, c.target, *((c.preparation,) if c.preparation else ()))))
    incomplete = False
    for expected in required:
      heard = actual.get(expected.event_id)
      if expected.start >= until:
        future[expected.event_id] = expected
        incomplete = True
      elif heard and heard.pitch == expected.pitch and heard.start == expected.start and heard.end == min(until, expected.end):
        future[expected.event_id] = expected
        incomplete |= heard.end < expected.end
      elif not heard or (heard.start, heard.end, heard.pitch) != (expected.start, expected.end, expected.pitch):
        return {}, (), c.id + ': missing/changed event before resolution deadline'
    if incomplete:
      pending.append(c)
  approved, error = validate(tuple(sorted(future.values(), key=lambda n: (n.start, n.event_id))), contracts, harmony, composition=composition)
  return {key: c for key, c in approved.items() if key in actual}, tuple(pending), error