"""General, independently authored capabilities; no optional reference inputs."""
import copy,dataclasses,unittest
from fractions import Fraction as F
from unittest.mock import patch
from generator import vocabulary,model
from generator.scales import selection,timeline
from generator.solo import analysis,construction,harmonic,profiles,types,scoring,composer,routes,placement
from tests import solo_fixtures as fixtures,rhythm_fixtures,scale_fixtures


def builder(symbols=('C7','FM7','Dm7','G7'),seed='independent',count=8):
  source=fixtures.song(count=count,chords=symbols);a=analysis.analyze(source);ms=source['staves'][0]['measures']
  end=sum(model.fraction(m['duration']) for m in ms)
  cs=selection.select(timeline.read(source['staves'][0]),timeline.Solo(F(),end,'test'),scale_fixtures.library())
  return construction.Builder(a,ms,harmonic.Harmony(cs,profiles.Instrument(reference=60)),fixtures.library(),rhythm_fixtures.library(),end,seed)

class PhraseConstruction(unittest.TestCase):
  def test_complete_candidates_have_varied_functions_and_joint_expression(self):
    b=builder();values=[b.propose(F(),(),i) for i in range(64)];values=[p for p in values if p]
    self.assertTrue(values)
    self.assertIn('open',{p.ending for p in values})
    self.assertTrue(any(p.destination and p.destination.duration>=2 for p in values))
    self.assertTrue(any(p.expressions for p in values))
    for p in values:
      self.assertTrue(b.harmony.evaluate(p.notes,until=p.end,complete=True,expressions=p.expressions).valid)
      self.assertEqual(p.score,p.evaluation.total)
      self.assertTrue(all(p.start<=n.start<n.end<=p.end for n in p.notes))

  def test_all_operations_are_eligible_and_construct_complete_music(self):
    b=builder(count=12);first=b.candidates(F(),())[0]
    history=(first,dataclasses.replace(first,id='second'))
    self.assertEqual(set(b.actions(history)),set(vocabulary.data('solo')['actions'])-{'head'})
    history=(*history,dataclasses.replace(first,id='third'))
    self.assertEqual(set(b.actions(history)),set(vocabulary.data('solo')['actions']))
    # Request each operation through the same active constructor in eligible contexts.
    for action in b.actions(history):
      with self.subTest(action=action),patch.object(b,'actions',return_value=[action]):
        candidates=[b.propose(F(16),history,i) for i in range(32)]
        self.assertTrue(any(p and p.purpose==action for p in candidates))

  def test_head_is_optional_not_required_rhythm(self):
    b=builder();b.analysis=dataclasses.replace(b.analysis,melody=())
    values=b.candidates(F(),())
    self.assertTrue(values)
    self.assertTrue(all(p.purpose!='head' for p in values))

  def test_recomposed_opening_is_not_source_hold(self):
    source=fixtures.song(count=4,chords=('CM7',))
    n=source['staves'][0]['measures'][0]['voices'][0]['notes'][0]
    source['staves'][0]['measures'][0]['voices'][0]['notes']=[{**n,'duration':model.rational(4),'pitches':[{**n['pitches'][0],'duration':model.rational(4)}]}]
    result=fixtures.compose(source)
    self.assertTrue(result.notes());self.assertLess(result.notes()[0].end-result.notes()[0].start,4)

  def test_disabled_expressions_are_strict_and_reproducible(self):
    b=builder();b.enabled=False
    ps=b.compose();ns=tuple(n for p in ps for n in p.notes)
    self.assertFalse(any(p.expressions for p in ps))
    self.assertTrue(all(n.pitch.number()%12 in types.permitted(b.harmony.choices,n.start,n.end) for n in ns))
    self.assertEqual(ps,b.compose())

  def test_role_domains_and_complete_tied_position(self):
    for role in ('acoustic','electric'):
      p=profiles.for_part(role)
      self.assertEqual(p.strings,(1,2,3,4,5,6))
      for midi in range(41,77):self.assertTrue(placement.positions(midi,p))
    a=fixtures.note(0,2,'e',event_id='held');ns=(a,dataclasses.replace(a,start=F(2),end=F(4),continuation=True))
    positioned=placement.place(ns,F(120))[1]
    self.assertEqual(positioned[0].position,positioned[1].position)
    self.assertEqual(len(types.sounding_notes(positioned)),1)

  def test_routes_keep_actual_pitches_across_collection_change(self):
    b=builder(('C7','DmM7'),count=2)
    ns=(fixtures.note(3,F(7,2),'g'),fixtures.note(F(7,2),4,'a'),fixtures.note(4,F(9,2),'c'),fixtures.note(F(9,2),5,'d'))
    values=b.routes.realize(ns,{0,3},'scalar','up','crossing',64)
    self.assertTrue(values)
    for route in values:
      self.assertEqual(route[0].pitch,ns[0].pitch);self.assertEqual(route[-1].pitch,ns[-1].pitch)
      self.assertTrue(all(n.pitch.number()%12 in types.permitted(b.harmony.choices,n.start,n.end) for n in route))

  def test_no_internal_chordal_endpoint_requirement(self):
    b=builder(('C7',),count=2)
    ns=(fixtures.note(0,F(1,2),'e'),fixtures.note(F(1,2),1,'f'))
    paths=b.routes.realize(ns,{0,1},'scalar','up','open',64)
    self.assertTrue(paths)
    self.assertTrue(b.harmony.evaluate(paths[0]).valid)
    self.assertNotIn(paths[0][-1].pitch.number()%12,b.harmony.at(F(1,2)).roles.basic)

  def test_meaningful_incoming_state_changes_continuations(self):
    b=builder();history=(b.candidates(F(),())[0],)
    a=b.candidates(history[-1].end,history)
    old=history[0];last=old.notes[-1]
    changed=dataclasses.replace(old,id='changed',notes=(*old.notes[:-1],dataclasses.replace(last,pitch=dataclasses.replace(last.pitch,octave=last.pitch.octave+1))))
    c=b.candidates(changed.end,(changed,))
    self.assertNotEqual(tuple(p.notes for p in a),tuple(p.notes for p in c))

  def test_no_short_accidental_handoff_tail(self):
    b=builder(count=4);ps=b.compose()
    self.assertEqual(ps[-1].end,b.end)
    if ps[-1].destination:self.assertGreaterEqual(ps[-1].destination.duration,2)

  def test_cache_restores_exact_music_without_source_ancestry_growth(self):
    b=builder(count=4);cold=b.candidates(F(),());warm=b.candidates(F(),())
    self.assertEqual(cold,warm)
    self.assertTrue(all(not n.sources for p in cold for n in p.notes))

class EvaluationContract(unittest.TestCase):
  def phrase(self,ns,**kwargs):return types.Phrase('test',F(),F(8),tuple(ns),'scalar','up','open',**kwargs)
  def test_configured_terms_are_authoritative_and_nonzero(self):
    ns=(fixtures.note(0,1,'c',octave=3),fixtures.note(1,2,'e',octave=4),fixtures.note(2,4,'c',octave=4))
    p=self.phrase(ns);incoming=fixtures.note(-1,0,'c',octave=5)
    base=scoring.evaluate(p,incoming,(p,),40)
    self.assertEqual(base.total,sum(base.contributions.values()))
    for name,value in base.raw.items():
      self.assertGreater(value,0,name)
      altered=scoring.evaluate(p,incoming,(p,),40,weights={**base.weights,name:base.weights[name]+1})
      self.assertAlmostEqual(altered.total-base.total,value)
  def test_silence_is_explicit_and_tie_partition_is_invariant(self):
    a=fixtures.note(0,4,'e',event_id='a')
    split=(dataclasses.replace(a,end=F(2)),dataclasses.replace(a,start=F(2),continuation=True))
    self.assertEqual(scoring.evaluate(self.phrase((a,)),None,(),60),scoring.evaluate(self.phrase(split),None,(),60))
    self.assertFalse(scoring.evaluate(self.phrase(()),None,(),60).valid)
    self.assertTrue(scoring.evaluate(dataclasses.replace(self.phrase(()),purpose='space'),None,(),60).valid)
  def test_target_touch_and_repeated_attacks_do_not_fulfill_hold(self):
    a=fixtures.note(2,4,'e',event_id='arrival')
    anchor=types.Anchor('held',F(2),F(2),a.pitch,frozenset({4}),(41,76),F(2),'terminal','C7',hold_until=F(4))
    ns=(dataclasses.replace(a,end=F(3)),dataclasses.replace(a,start=F(3),event_id='again'))
    self.assertFalse(harmonic.anchors_valid((anchor,),ns,F(4),complete=True,closure='closed')[0])
    self.assertTrue(harmonic.anchors_valid((anchor,),(a,),F(4),complete=True,closure='closed')[0])

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