"""Instantiate complete authored routes; a failed path is never repaired note by note."""
from __future__ import annotations

import dataclasses
import fractions

import generator.fretboard
import generator.solo.placement
import generator.solo.policy
import generator.solo.sequences
import generator.solo.types as types
import generator.vocabulary


def path_cost(notes):
  """Penalize unexplained extremes, not every third or arpeggio interval."""
  intervals=[b.pitch.number()-a.pitch.number() for a,b in zip(notes,notes[1:])]
  excess=sum(max(0,abs(v)-7) for v in intervals)/max(1,len(intervals))
  oscillation=sum(a!=0 and a==-b and a==c and b==d for a,b,c,d in zip(intervals,intervals[1:],intervals[2:],intervals[3:]))
  return excess+.1*oscillation


def path_family(notes,harmony):
  intervals=tuple(b.pitch.number()-a.pitch.number() for a,b in zip(notes,notes[1:]))
  chordal=all(n.pitch.number()%12 in harmony.members(n.start,n.end) for n in notes)
  return ('arpeggio' if chordal and any(abs(v)>=3 for v in intervals) else 'mapped',
    generator.solo.sequences.family(intervals))

def advance(scale, previous, step):
  try:
    degree = types.scale_index(scale, previous)
    return tuple([types.scale_pitch(scale, degree + step)])
  except ValueError:
    # At a changed collection count actual intervening scale tones from the
    # incoming sound. No old degree number is transferred to the new scale.
    if not step:
      return ()
    nearby = sorted((types.scale_pitch(scale, i) for i in range(-28, 35)), key=lambda p: p.number())
    outgoing = [p for p in nearby if (p.number() - previous) * step > 0]
    if step < 0:
      outgoing.reverse()
    return tuple(outgoing[abs(step) - 1:abs(step)])

def candidates(notes, fixed, harmony, library, register, relationship='connect theme', *, purpose='connect', expressions=()):
  if expressions:
    return planned_candidates(notes,fixed,harmony,register,relationship,expressions)
  # Cache concrete routes only with their endpoints, timing, scale context and
  # vocabulary. The per-Harmony cache cannot leak across collection changes.
  if not hasattr(harmony,'route_cache'):
    harmony.route_cache={}
    harmony.route_libraries={}
    harmony.concrete_routes={}
  harmony.route_libraries[id(library)]=library
  concrete_key=(notes,frozenset(fixed),id(library),register,harmony.profile,purpose)
  if concrete_key in harmony.concrete_routes:
    return tuple(dataclasses.replace(r,relationship=relationship) for r in harmony.concrete_routes[concrete_key])
  # Event/source IDs and non-fixed placeholder pitches do not affect route
  # feasibility. Cache the pitch work across different thematic histories,
  # then restore this caller's provenance before ranking complete routes.
  fixed_indices=frozenset(i for i,n in enumerate(notes) if n.event_id in fixed)
  canonical=tuple(dataclasses.replace(n,sources=(),event_id=str(i),role='connection',position=None,
    pitch=n.pitch if i==0 or i==len(notes)-1 or i in fixed_indices else types.Pitch('c',fractions.Fraction(),0)) for i,n in enumerate(notes))
  key=(canonical,fixed_indices,id(library),register,harmony.profile,purpose)
  if key not in harmony.route_cache:
    harmony.route_cache[key]=_candidates(canonical,{str(i) for i in fixed_indices},harmony,library,register,purpose)
  result=[]
  for route in harmony.route_cache[key]:
    actual=tuple(n if i==0 else dataclasses.replace(n,pitch=n.pitch if n.pitch.number()==r.pitch.number() else r.pitch,position=None)
      for i,(n,r) in enumerate(zip(notes,route.notes)))
    identity=generator.solo.policy.stable_rank('complete-route',(actual,route.sources))[:16]
    result.append(dataclasses.replace(route,id=identity,notes=actual,destination=notes[-1],relationship=relationship))
  selected=generator.solo.sequences.diverse(result,
    lambda r:(path_cost(r.notes),r.id),
    lambda r:path_family(r.notes,harmony),
    generator.solo.policy.DEFAULT.join_alternatives)
  if len(harmony.concrete_routes)>=8192:harmony.concrete_routes.pop(next(iter(harmony.concrete_routes)))
  if len(harmony.route_cache)>=8192:harmony.route_cache.pop(next(iter(harmony.route_cache)))
  harmony.concrete_routes[concrete_key]=selected
  return selected


def planned_candidates(notes,fixed,harmony,register,relationship,contracts):
  # Cache complete contract-conditioned pitch work, not a next-note suggestion.
  # IDs/provenance are restored below; timing, pitch, role, obligations and
  # profile remain in the key. The cache is owned by this harmonic timeline.
  ids={n.event_id:str(i) for i,n in enumerate(notes)}
  canonical=tuple(dataclasses.replace(n,sources=(),event_id=str(i)) for i,n in enumerate(notes))
  def note(n):return canonical[int(ids[n.event_id])]
  obligations=tuple(dataclasses.replace(c,id=str(i),events=tuple(map(note,c.events)),
    target=note(c.target),preparation=note(c.preparation) if c.preparation else None) for i,c in enumerate(contracts))
  locked=frozenset(ids[i] for i in fixed)
  key=(canonical,locked,register,harmony.profile,obligations)
  if not hasattr(harmony,'planned_route_cache'):harmony.planned_route_cache={}
  if key not in harmony.planned_route_cache:
    harmony.planned_route_cache[key]=_planned_candidates(canonical,locked,harmony,register,'',obligations)
    if len(harmony.planned_route_cache)>8192:harmony.planned_route_cache.pop(next(iter(harmony.planned_route_cache)))
  result=[]
  for route in harmony.planned_route_cache[key]:
    actual=tuple(dataclasses.replace(original,pitch=realized.pitch,position=realized.position) for original,realized in zip(notes,route.notes))
    result.append(dataclasses.replace(route,notes=actual,destination=actual[-1],relationship=relationship))
  return tuple(result)


def _planned_candidates(notes,fixed,harmony,register,relationship,contracts):
  """Solve the whole route around explicit, preselected harmonic obligations.

  Fixed expressive pitches have narrow permissions; all other attacks use the
  map. Complete contracts are checked after realization, never inferred merely
  from a label. No incomplete route is handed back to the next cell.
  """
  from generator.solo import gestures
  proposal=gestures.Proposal(notes,contracts,relationship)
  locked={n.event_id for c in contracts for n in (*c.events,c.target)}|set(fixed)|{notes[0].event_id,notes[-1].event_id}
  special={n.event_id for c in contracts for n in c.events}
  states=[(0.,(notes[0],))]
  for i,n in enumerate(notes[1:],1):
    span=harmony.at(n.start)
    if not span or not span.scale:return ()
    allowed=types.permitted(harmony.choices,n.start,n.end)
    if n.end-n.start>=2 and n.event_id not in special:allowed &= harmony.members(n.start,n.end)
    target=next((a for a in notes[i:] if a.event_id in locked),notes[-1])
    remaining=max(1,sum(a.start<target.start for a in notes[i:]))
    following=[]
    for cost,path in states:
      prior=path[-1]
      if n.event_id in locked:options=(n.pitch,)
      else:
        options=tuple(p for step in (-3,-2,-1,1,2,3) for p in advance(span.scale,prior.pitch.number(),step))
        if prior.pitch.number()%12 in allowed:options=(*options,prior.pitch)
      for pitch in options:
        number=pitch.number()
        if not harmony.profile.permits(number) or not register[0]<=number<=register[1]:continue
        if n.event_id not in special and number%12 not in allowed:continue
        motion=number-prior.pitch.number()
        if abs(motion)>12:continue
        # Continuation aims at the known future destination. Selected thirds
        # and fourths remain feasible; repeated oscillation is not progress.
        distance=abs(target.pitch.number()-number)
        remaining_cost=max(0,distance-5*remaining)/12
        repeating=len(path)>1 and path[-2].pitch==prior.pitch==pitch
        value=cost+max(0,abs(motion)-7)/12+.2*repeating
        following.append((value,(*path,dataclasses.replace(n,pitch=pitch,position=None)),remaining_cost))
    chosen=generator.solo.sequences.diverse(following,lambda v:(v[0]+v[2],tuple(n.pitch.number() for n in v[1])),
      lambda v:(generator.solo.sequences.family(tuple(b.pitch.number()-a.pitch.number() for a,b in zip(v[1],v[1][1:]))),v[1][-1].pitch.number()),8)
    states=[(cost,path) for cost,path,_ in chosen]
    if not states:return ()
  result=[]
  for _,actual in states:
    bound=proposal.bind(actual)
    if not harmony.evaluate(actual,until=actual[-1].end,complete=True,expressions=bound).valid:continue
    identity=generator.solo.policy.stable_rank('planned-route',tuple((n.start,n.end,n.pitch) for n in actual))[:16]
    result.append(types.RouteCandidate(identity,actual,actual[-1],(),relationship,tuple('gesture:'+c.rule for c in bound)))
  return tuple(result)

def _candidates(notes, fixed, harmony, library, register, purpose='connect'):
  """Every returned candidate includes its entry, complete rhythm and destination.

  Callers validate the whole surrounding sounding context and guitar path.
  This function applies exact scale paths, fixed events and range constraints.
  """
  if not 2 <= len(notes) <= 16:
    return ()
  first, destination = notes[0], notes[-1]
  span = harmony.at(first.start)
  if not span or not span.scale:
    return ()
  contexts=tuple((harmony.at(n.start).scale if harmony.at(n.start) else None,
    types.permitted(harmony.choices,n.start,n.end) & (harmony.members(n.start,n.end) if n.end-n.start>=2 else frozenset(range(12))),
    n.pitch.number() if n.event_id in fixed or i==len(notes)-1 else None) for i,n in enumerate(notes))
  if not hasattr(harmony,'pitch_routes'):harmony.pitch_routes={}
  key=(first.pitch,contexts,id(library),register,harmony.profile)
  if key not in harmony.pitch_routes:
    harmony.pitch_routes[key]=pitch_paths(first.pitch,contexts,library,register,harmony.profile)
    if len(harmony.pitch_routes)>8192:harmony.pitch_routes.pop(next(iter(harmony.pitch_routes)))
  route_spans=tuple((max(first.start,c.span.start),min(destination.end,c.span.end),c.scale.label())
    for c in harmony.choices if c.scale and c.span.start<destination.end and c.span.end>first.start)
  result=[]
  paths=list(harmony.pitch_routes[key])
  # These are traversal operators, not stored phrases. An arpeggio prefix
  # adapts to the chord at each note and a complete scale route then connects
  # it to this caller's actual destination. No endpoint is attacked twice.
  for prefix,rule in chord_prefixes(notes,fixed,harmony,register,purpose):
    i=len(prefix)-1
    if i==len(notes)-1:
      if prefix[-1].pitch.number()==destination.pitch.number():
        paths.append((tuple(n.pitch for n in prefix),('chord-path:'+rule,)))
      continue
    suffix_key=(prefix[-1].pitch,contexts[i:],id(library),register,harmony.profile)
    if suffix_key not in harmony.pitch_routes:
      while len(harmony.pitch_routes)>=8192:
        harmony.pitch_routes.pop(next(iter(harmony.pitch_routes)))
      harmony.pitch_routes[suffix_key]=pitch_paths(prefix[-1].pitch,contexts[i:],library,register,harmony.profile)
    for tail,sources in harmony.pitch_routes[suffix_key][:2]:
      paths.append((tuple(n.pitch for n in prefix[:-1])+tail,('chord-path:'+rule,*sources)))
  for pitches,sources in paths:
    realized=(first,*(dataclasses.replace(n,pitch=n.pitch if n.pitch.number()==p.number() else p,position=None)
      for n,p in zip(notes[1:],pitches[1:])))
    identity=generator.solo.policy.stable_rank('complete-route',(realized,sources))[:16]
    result.append(types.RouteCandidate(identity,realized,destination,route_spans,'connect theme',sources))
  return tuple(result)


def chord_prefixes(notes,fixed,harmony,register,purpose):
  from generator.solo import phrasing
  if len(notes)<2:return ()
  values=[]
  first=notes[0];destination=notes[-1]
  for rule in generator.vocabulary.data('melodic_vocabulary')['chord_paths']:
    if purpose not in rule['purpose']:continue
    if rule['require_chord_entry'] and first.pitch.number()%12 not in harmony.members(first.start,first.end):continue
    displacement=destination.pitch.number()-first.pitch.number()
    direction=1 if rule['direction']=='up' else -1 if rule['direction']=='down' else (1 if displacement>=0 else -1)
    for count in rule['prefix_attacks']:
      if count>len(notes):continue
      prefix=[first]
      for i,n in enumerate(notes[1:count]):
        span=harmony.at(n.start)
        if not span or not span.scale:break
        eligible=harmony.members(n.start,n.end)&types.permitted(harmony.choices,n.start,n.end)
        if rule['members']=='defining':eligible=eligible&phrasing.defining_members(span.chord)
        step=rule['member_steps'][i%len(rule['member_steps'])]
        old=prefix[-1].pitch.number()
        pitches=sorted((types.scale_pitch(span.scale,j) for j in range(-21,29)),key=lambda p:p.number(),reverse=direction*step<0)
        options=[p for p in pitches if p.number()%12 in eligible and 0<(p.number()-old)*direction*step
          and abs(p.number()-old)<=rule['max_interval'] and register[0]<=p.number()<=register[1] and harmony.profile.permits(p.number())]
        if len(options)<abs(step):break
        selected=options[abs(step)-1]
        if (n.event_id in fixed or i+1==len(notes)-1) and selected.number()!=n.pitch.number():break
        prefix.append(dataclasses.replace(n,pitch=selected))
      if len(prefix)==count:values.append((tuple(prefix),rule['id']))
  return tuple(values)


def pitch_paths(first, contexts, library, register, profile=None):
  """Time-independent pitch work; context includes every overlapped collection.

  Sounding durations and chord roles are still validated on each concrete
  realization. Equal collection contexts can reuse paths across rhythmic edits.
  """
  from generator.solo.profiles import UNRESTRICTED
  profile = profile or UNRESTRICTED
  if not profile.permits(first.number()): return ()
  destination=contexts[-1][2]
  try:
    displacement=types.scale_index(contexts[0][0],destination)-types.scale_index(contexts[0][0],first.number())
    displacements=(displacement,)
  except ValueError:
    displacements=tuple(range(-7,8))
  direction=(destination>first.number())-(destination<first.number())
  paths=dict.fromkeys(path for d in displacements for path in library.retrieve(len(contexts),d,direction))
  low,high=generator.fretboard.single_register((register[0]-7,register[1]+5))
  low, high = max(low, profile.register[0]), min(high, profile.register[1])
  result=[]
  # Reattacks are an explicit primitive, separate from interval catalog paths
  # (whose zero steps are deliberately excluded). Tied holds remain one event.
  if all(first.number()%12 in allowed and (fixed is None or fixed==first.number())
    for _,allowed,fixed in contexts):
    result.append(((first,)*len(contexts),('primitive:repeated_attack',)))
  for path in paths:
    realized=[first]
    for (scale,allowed,fixed),step in zip(contexts[1:],path.steps):
      if not scale:break
      options=advance(scale,realized[-1].number(),step)
      if not options:break
      pitch=options[0];number=pitch.number()
      if not low<=number<=high or number%12 not in allowed:break
      if fixed is not None and number!=fixed:break
      if not generator.solo.placement.positions(number,profile):break
      realized.append(pitch)
    if len(realized)==len(contexts):result.append((tuple(realized),path.sources))
  return tuple(result)