from __future__ import annotations

import copy
import fractions
import itertools

import generator.accompaniment
import generator.model
import generator.score
import generator.solo.types

def durations(length):
  if length.denominator & (length.denominator - 1) == 0:
    yield from generator.accompaniment.written_durations(length)
  else:
    kind, base = next((kind, value) for kind, value in reversed(generator.model.TYPE_LENGTHS.items()) if value >= length)
    yield length, {'type': kind, 'dots': 0, 'ratio': generator.model.rational(length / base)}

def measures(sources: list[dict], notes: tuple[generator.solo.types.Note, ...], prefix: str) -> list[dict]:
  """Write attack spans as conventional durations; only continuations get ties."""
  result, previous = [], {}
  absolute = fractions.Fraction()
  for index, source in enumerate(sources):
    length = generator.model.fraction(source['duration'])
    events, cursor = [], absolute

    def emit(start, end, tone=None, identity=None):
      for duration, written in durations(end - start):
        identifier = f'{prefix}_{index + 1}_{len(events) + 1}'
        pitches = [tone.pitch.written() | {'tablature': {'string': tone.position.string_number, 'fret': tone.position.fret}}] if tone else []
        event = generator.model.make_event(identifier, start - absolute, duration, 'note' if tone else 'rest', pitches, written)
        if tone:
          pitch = event['pitches'][0]
          if identity in previous:
            prior = previous[identity]
            prior['tie_to'] = pitch['id']
            pitch['tie_from'] = prior['id']
          previous[identity] = pitch
        events.append(event)
        start += duration

    for identity, note in enumerate(notes):
      start, end = max(absolute, note.start), min(absolute + length, note.end)
      if start >= end:
        continue
      if start > cursor:
        emit(cursor, start)
      emit(start, end, note, identity)
      cursor = end
    if cursor < absolute + length:
      emit(cursor, absolute + length)
    measure = generator.score.make_measure(source['id'], source, events, section_label=source.get('section_label', ''))
    measure['transpose'] = {'diatonic': 0, 'chromatic': 0, 'octave_change': -1, 'explicit': True}
    measure['clef'] = {'sign': 'G', 'line': 2, 'octave_change': 0}
    for change in measure.get('attributes', []):
      change.pop('transpose', None)
      change.pop('clef', None)
    result.append(measure)
    absolute += length
  return result

def tuplets(measures):
  # Group by sounding duration, including notation fragments across barlines.
  spans = []
  events = [n for m in measures for n in generator.score.measure_notes(m)]
  for ratio, values in itertools.groupby(events, key=lambda n: generator.model.fraction(n['written'].get('ratio', generator.model.rational(1)))):
    if ratio == 1:
      continue
    members = []
    elapsed = fractions.Fraction()
    length = None
    for note in values:
      if not members:
        length = generator.model.TYPE_LENGTHS[note['written']['type']] * ratio.numerator
      members.append(note)
      elapsed += generator.model.fraction(note['duration'])
      if elapsed >= length:
        identifier = members[0]['id'] + '_tuplet'
        spans.append({'id': identifier, 'voice': 'voice_arranged', 'start': members[0]['id'], 'end': members[-1]['id'], 'note_count': ratio.denominator, 'space_count': ratio.numerator, 'depth': 0, 'bracket': 'auto', 'show_number': 'actual'})
        for n in members:
          n['tuplet_ids'] = [identifier]
        members = []
        elapsed = fractions.Fraction()
    if members:
      identifier = members[0]['id'] + '_tuplet'
      spans.append({'id': identifier, 'voice': 'voice_arranged', 'start': members[0]['id'], 'end': members[-1]['id'], 'note_count': ratio.denominator, 'space_count': ratio.numerator, 'depth': 0, 'bracket': 'auto', 'show_number': 'actual'})
      for n in members:
        n['tuplet_ids'] = [identifier]
  return spans

def replace_region(document: dict, first: int, replacement: list[dict]) -> None:
  staff = document['staves'][0]
  replacement = copy.deepcopy(replacement)
  spans = tuplets(replacement)
  staff['measures'][first:first + len(replacement)] = replacement
  staff['tablature'] = True
  existing = {n['id'] for m in staff['measures'] for n in generator.score.measure_notes(m)}
  staff['tuplets'] = [t for t in staff.get('tuplets', []) if t['start'] in existing and t['end'] in existing] + spans