"""Independent musical fixtures; the four optional user scores are never read."""
import copy
import dataclasses
import json
from fractions import Fraction as F
from pathlib import Path
import tempfile
from types import SimpleNamespace
import unittest

from audition import reference_review, solo_compare
from generator import vocabulary, production
from generator.solo import export, gesture_rhythm, harmonic, notation, placement, routes, themes, types
from tests.test_solo import song
from tests.test_solo_development import note
from tests.test_solo_passages import choices
from tests import solo_fixtures


def xml(notes, *, transpose=False, leadin=''):
  return '<score-partwise version="4.0"><part-list><score-part id="P"><part-name>Vocal</part-name></score-part></part-list><part id="P">'+leadin+'<measure number="1"><attributes><divisions>6</divisions><key><fifths>0</fifths></key><time><beats>4</beats><beat-type>4</beat-type></time><clef><sign>G</sign><line>2</line></clef>'+('<transpose><chromatic>0</chromatic><octave-change>-1</octave-change></transpose>' if transpose else '')+'</attributes><harmony><root><root-step>C</root-step></root><kind>major-seventh</kind></harmony>'+notes+'</measure></part></score-partwise>'


def pitched(duration, tie='', octave=5):
  return f'<note><pitch><step>C</step><octave>{octave}</octave></pitch><duration>{duration}</duration>{tie}<type>quarter</type></note>'


class ComparisonTests(unittest.TestCase):
  def review(self,directory,name,content,**kwargs):
    path=Path(directory)/name;path.write_text(content)
    return reference_review.read(path,'fixture/acoustic',**kwargs)

  def test_ties_not_reattacks_and_one_guitar_transposition(self):
    with tempfile.TemporaryDirectory() as root:
      a=self.review(root,'actual.xml',xml(pitched(24),transpose=True),form_start=1)
      b=self.review(root,'reference.xml',xml(pitched(12,'<tie type="start"/>')+pitched(12,'<tie type="stop"/>')),form_start=1,pitch_convention='guitar-written')
      self.assertTrue(solo_compare.compare(a,b)['exact_musical_match'])
      self.assertEqual(a['sounding_events'][0]['sounding_midi'],'60')
      repeated=self.review(root,'repeat.xml',xml(pitched(12)+pitched(12)),form_start=1,pitch_convention='guitar-written')
      self.assertFalse(solo_compare.compare(a,repeated)['exact_musical_match'])

  def test_leadin_is_reported_without_harmony_or_alignment_padding(self):
    with tempfile.TemporaryDirectory() as root:
      prelude='<measure number="0"><attributes><divisions>6</divisions></attributes>'+pitched(6)+'<note><rest/><duration>18</duration></note></measure>'
      a=self.review(root,'a.xml',xml(pitched(24),transpose=True),form_start=1)
      b=self.review(root,'b.xml',xml(pitched(24),leadin=prelude),form_start=2,pitch_convention='guitar-written')
      result=solo_compare.compare(a,b)
      self.assertEqual(result['differences'][0]['time'],'-4')
      self.assertEqual(result['exact_matching_attacks'],1)
      self.assertIn('uncertainty',b['notes'][0]['harmonic_spans'][0])

  def test_unplayable_pitch_is_reported_not_folded(self):
    with tempfile.TemporaryDirectory() as root:
      r=self.review(root,'high.xml',xml(pitched(24,octave=7)),form_start=1,pitch_convention='guitar-written')
      checked=solo_compare.playability(r)
      self.assertEqual(checked['conflicts'][0]['sounding_midi'],84)
      self.assertEqual(r['notes'][0]['pitch']['octave'],7)

  def test_silent_reference_leadin_remains_in_audition_clock(self):
    with tempfile.TemporaryDirectory() as root:
      prelude='<measure number="0"><attributes><divisions>6</divisions></attributes><note><rest/><duration>24</duration></note></measure>'
      a=self.review(root,'actual.xml',xml(pitched(24),transpose=True),form_start=1)
      b=self.review(root,'reference.xml',xml(pitched(24),leadin=prelude),form_start=2,pitch_convention='guitar-written')
      self.assertEqual(solo_compare.audition_bounds(a,b),(F(-4),F(4)))

  def test_triplet_time_and_annotations_are_literal(self):
    with tempfile.TemporaryDirectory() as root:
      triplet=pitched(2).replace('<type>quarter</type>','<type>eighth</type><time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>')
      r=self.review(root,'thirds.xml',xml('<direction><direction-type><words>Lead in</words></direction-type></direction>'+triplet*3+'<note><rest/><duration>18</duration></note>'),form_start=1)
      self.assertEqual([n['start'] for n in r['sounding_events']],['0','1/3','2/3'])
      self.assertEqual(r['annotations'][0]['text'],'Lead in')

  def test_export_roundtrip_preserves_actual_sounding_events_and_tab(self):
    document=song(count=2,chords=('CM7',))
    raw=(note(0,F(1,3),'c'),note(F(1,3),F(2,3),'d'),note(F(2,3),1,'e'),note(F(7,2),5,'g'),note(5,6,'g'))
    placed=placement.place(raw,F(120))[1]
    notation.replace_region(document,0,notation.measures(document['staves'][0]['measures'],placed,'export'))
    document['staves'][0]['measures'][0]['section_label']='Acoustic Solo'
    before=copy.deepcopy(document)
    with tempfile.TemporaryDirectory() as root:
      path=Path(root)/'fixture-solo1.xml'
      info=export.write_role({'role':'acoustic_solo','document':document,'trace':{'source':'fixture'}},path)
      loaded=reference_review.read(path,'fixture/acoustic',1)
      sounded=[(F(n['start']),F(n['end']),F(n['sounding_midi'])) for n in loaded['sounding_events']]
      self.assertEqual([(n.start,n.end,n.pitch.number()) for n in raw],sounded)
      from generator import score
      tab=lambda d:[p['tablature'] for m in d['staves'][0]['measures'] for n in score.measure_notes(m) for p in n['pitches']]
      self.assertEqual(tab(document),[n['tablature'] for n in loaded['notes'] if n['pitch']])
      self.assertEqual(info['role'],'acoustic_solo')
    self.assertEqual(before,document)

  def test_export_manifests_are_not_discovered_as_runtime_scores(self):
    from generator import score
    document=song(count=1,chords=('CM7',))
    with tempfile.TemporaryDirectory() as root:
      root=Path(root);(root/'analysis').mkdir()
      roles={}
      for part in ('acoustic','electric'):
        doc=copy.deepcopy(document)
        doc['staves'][0]['measures'][0]['section_label']=part.capitalize()+' Solo'
        roles[part+'_solo']={'role':part+'_solo','document':doc,'trace':{'source':'synthetic'}}
      (root/'analysis'/'fixture.roles').write_text(json.dumps(roles))
      score.write_json(root/'score.json',document)
      export.export_tree(root)
      self.assertEqual(score.count_json_files(root),1)
      score.validate_generated_tree(root)
      self.assertTrue((root/'solo_xml'/'fixture-solo1.xml').is_file())
      self.assertTrue((root/'solo_xml'/'fixture-solo2.xml').is_file())


class MusicalSelectionTests(unittest.TestCase):
  def test_cell_purpose_survives_loading_and_filters_eligibility(self):
    cells=tuple(vocabulary.rhythm_cells(120,'arrival'))
    self.assertTrue(cells)
    self.assertTrue(all(c.purpose=='arrival' for c in cells))
    self.assertFalse(any(c.id=='short_answer' for c in cells))

  def test_connecting_rhythm_prefers_groups_to_isolated_notes(self):
    joined=((F(),F(1,2)),(F(1,2),F(3,2)),(F(3,2),F(2)))
    fragmented=((F(),F(1,2)),(F(1),F(3,2)),(F(2),F(5,2)))
    self.assertLess(themes.rhythm_cost(joined,F(4),'connect'),themes.rhythm_cost(fragmented,F(4),'connect'))

  def test_complete_signature_boundary_can_cross_barline(self):
    home=SimpleNamespace(signature=(note(0,2),note(2,5)))
    source=SimpleNamespace(end=F(24));ending=SimpleNamespace(earliest=F(21))
    self.assertEqual(themes.unit_end(source,F(8),home,ending,F(4)),13)

  def test_arpeggio_is_not_charged_for_each_nonstep_interval(self):
    chord=(note(0,F(1,2),'c'),note(F(1,2),1,'e'),note(1,F(3,2),'g'))
    steps=(note(0,F(1,2),'c'),note(F(1,2),1,'d'),note(1,F(3,2),'e'))
    self.assertEqual(routes.path_cost(chord),routes.path_cost(steps))
    h=harmonic.Harmony(choices(('CM7',)))
    self.assertEqual(routes.path_family(chord,h)[0],'arpeggio')
    self.assertEqual(routes.path_family(steps,h)[0],'mapped')
    run=tuple(note(i,F(i+1),p) for i,p in enumerate(('c','d','e','f','g','a')))
    self.assertEqual(routes.path_cost(run),0)
    oscillation=tuple(note(i,F(i+1),p) for i,p in enumerate(('c','d','c','d','c')))
    self.assertGreater(routes.path_cost(oscillation),0)

  def test_data_driven_arpeggio_reaches_exact_destination_as_one_route(self):
    h=harmonic.Harmony(choices(('CM7',)))
    notes=(note(0,F(1,2),'c',event_id='first'),note(F(1,2),1,'c',event_id='middle'),note(1,F(3,2),'g',event_id='target'))
    paths=routes.candidates(notes,{'target'},h,solo_fixtures.library(),(41,76))
    authored=[r for r in paths if any(s.startswith('chord-path:') for s in r.sources)]
    self.assertTrue(authored)
    self.assertTrue(any([n.pitch.number() for n in r.notes]==[60,64,67] for r in authored))
    self.assertTrue(all(r.notes[-1].pitch==notes[-1].pitch for r in paths))
    self.assertTrue(all(h.evaluate(r.notes).valid for r in paths))

  def test_solo_vocabulary_changes_do_not_change_accompaniment_inputs(self):
    resources=vocabulary.load()
    changed=copy.deepcopy(resources)
    changed['melodic_vocabulary']['cells'].append({'id':'independent-test'})
    for role in ('acoustic_accompaniment','electric_accompaniment','electric_melody','vocal_melody'):
      self.assertEqual(production.dependencies(role,resources),production.dependencies(role,changed))
    self.assertNotEqual(production.dependencies('acoustic_solo',resources),production.dependencies('acoustic_solo',changed))

  def test_cross_bar_arrival_cell_remains_one_sounding_duration(self):
    cell=next(c for c in vocabulary.rhythm_cells(120,'arrival') if c.id=='anticipated_sustain')
    self.assertTrue(any(a<4<b for a,b in cell.pattern))

  def test_shared_provisional_arrival_preserves_terminal_hold(self):
    a=note(0,1,'c',event_id='a');b=note(1,2,'c',event_id='b');c=note(2,4,'e',event_id='c')
    t=lambda id,start,end,operation,events:types.Transformation(id,'source','home',operation,F(start),F(end),events,(),preserves=())
    draft=types.MelodicDraft('draft',F(),F(4),(a,b,c),(t('a',0,1,'introduce',('a',)),t('b',1,4,'continue',('b','c'))),(),(),(),None,'continue')
    h=harmonic.Harmony(choices(('CM7',)))
    revised,edits=gesture_rhythm.shared_arrival(draft,h)
    self.assertEqual(len(revised.notes),2)
    self.assertEqual(revised.notes[0].start,0)
    self.assertEqual(revised.notes[-1],c)
    self.assertEqual(edits[0].kind,'shared_arrival')
    self.assertEqual(gesture_rhythm.revise(draft,h)[1][0].kind,'shared_arrival')
    protected=dataclasses.replace(draft,protected=('a',))
    self.assertEqual(gesture_rhythm.shared_arrival(protected,h)[0],protected)


if __name__=='__main__':unittest.main()