import copy
import argparse
from fractions import Fraction
import hashlib
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
from xml.etree import ElementTree

from generator.arrange.generate import arrange_document
from generator.__main__ import generate_assets
from generator.engraving import ENGINE_NAME, EngravingError, Fonts, Style, check_page, engrave_tree, layout_score
from tests.musicxml_roundtrip import audit_roundtrip
from generator.model import fraction, pitch_number, rational, validate_document
from generator.musicxml import load_musicxml
from generator.musicxml_writer import write_musicxml
from generator.practice.generate import practice_document
from generator.score import load_json
from generator.pitch import concert_document
from tests.test_musicxml import notes, parse, xml_note, xml_score

class ScoreBundleTests(unittest.TestCase):
  def test_real_asset_regeneration_removes_pages_and_rolls_back_font_failure(self):
    with tempfile.TemporaryDirectory() as temporary:
      root = Path(temporary)
      data, output = root / 'data', root / 'output'
      (data / 'songs').mkdir(parents=True)
      (data / 'practice').mkdir()
      source = data / 'practice/001.xml'
      source.write_text(xml_score(xml_note()))
      args = argparse.Namespace(data_dir=data, output_dir=output, static_assets_dir=Path('package/assets'), check=False)
      generate_assets(args)
      original = {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()}
      self.assertTrue(list(output.rglob('*.png')))
      (data / 'rhythms' / 'drafts').mkdir(parents=True)
      for path in ('rhythms/001.xml', 'rhythms/drafts/002.xml'):
        (data / path).write_text('<unfinished')
      generate_assets(args)
      self.assertEqual(original, {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()})
      misplaced = data / '001.xml'
      misplaced.write_text(xml_score(xml_note()))
      with self.assertRaisesRegex(ValueError, 'belong directly under'):
        generate_assets(args)
      misplaced.unlink()
      with patch('generator.__main__.compile_tree', side_effect=ValueError('invalid generated audio')):
        with self.assertRaisesRegex(ValueError, 'audio'):
          generate_assets(args)
      self.assertEqual(original, {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()})
      source.write_text(xml_score(xml_note() + '<barline><repeat direction="backward"/></barline>'))
      with self.assertRaisesRegex(ValueError, 'write the music out'):
        generate_assets(args)
      self.assertEqual(original, {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()})
      source.write_text(xml_score(xml_note(extra='<accidental smufl="unavailableGlyph">other</accidental>')))
      with self.assertRaisesRegex(EngravingError, 'unavailableGlyph'):
        generate_assets(args)
      self.assertEqual(original, {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()})
      source.write_text(xml_score(xml_note()))
      renamed = data / 'practice/127.xml'
      source.rename(renamed)
      source = renamed
      generate_assets(args)
      self.assertFalse((output / 'practice/001').exists())
      self.assertEqual(len(list((output / 'practice/127').glob('*.json'))), 3)
      source.unlink()
      generate_assets(args)
      self.assertFalse(list(output.rglob('*.png')))
      self.assertFalse(list(output.rglob('*.json')))
  def round_trip(self, document):
    with tempfile.TemporaryDirectory() as temporary:
      path = Path(temporary) / 'roundtrip.xml'
      write_musicxml(path, document)
      return load_musicxml(path)
  def test_score_structure_is_validated_without_schema_labels(self):
    document = parse(xml_score(xml_note()))
    self.assertEqual(set(document), {'metadata', 'staves'})
    for malformed in (None, [], {}, {'metadata': {}, 'staves': []}, {**document, 'staves': None}, {**document, 'staves': [{}]}):
      with self.subTest(document=malformed), self.assertRaises(ValueError):
        validate_document(malformed)
  def test_multiple_voices_keep_independent_ties_and_transformations(self):
    def half(action):
      return xml_note(duration=2, kind='half', extra=f'<voice>1</voice><tie type="{action}"/>')
    content = half('start') + half('stop') + '<backup><duration>4</duration></backup>'
    content += xml_note('C', extra='<voice>2</voice>')
    source = parse(xml_score(content))
    measure = source['staves'][0]['measures'][0]
    self.assertEqual([v['id'] for v in measure['voices']], ['1', '2'])
    self.assertNotIn('tie_from', measure['voices'][1]['notes'][0]['pitches'][0])
    for document in (source, concert_document(source), arrange_document(source, 'vocal')):
      validate_document(document)
      restored = self.round_trip(document)
      validate_document(restored)
      self.assertTrue(any(len(m['voices']) == 2 for m in restored['staves'][0]['measures']))
  def test_contiguous_ties_continue_across_systems_without_repeat_state(self):
    from generator.engraving.layout import make_system
    from generator.engraving.notation import ScoreIndex
    from generator.playback import compile_timeline
    text = xml_score(xml_note(extra='<tie type="start"/>'))
    text = text.replace('</measure></part>', '</measure><measure number="2">' + xml_note(extra='<tie type="stop"/>') + '<barline><bar-style>light-heavy</bar-style></barline></measure></part>')
    source = parse(text)
    index = ScoreIndex(source)
    fonts = Fonts(Path('package/assets/fonts/petaluma'))
    for start, end in ((0, 4), (4, 8)):
      system = make_system(index, start, end, fonts, Style())
      self.assertTrue(any(p.role == 'tie' and len(p.sources) == 2 for p in system.primitives))
    self.assertEqual([fraction(e['duration']) for e in compile_timeline(source)['events']], [8])
    restored = self.round_trip(source)
    self.assertEqual(notes(restored)[0]['pitches'], notes(source)[0]['pitches'])
    self.assertEqual(restored['staves'][0]['measures'][1]['barlines'], {'right': 'light-heavy'})
  def test_microtones_remain_exact_after_transposition_and_export(self):
    source = parse(xml_score(xml_note(alter='0.5', extra='<accidental>quarter-sharp</accidental>')))
    source['staves'][0]['measures'][0]['transpose'] = {'diatonic': 1, 'chromatic': 2, 'octave_change': 0}
    transposed = concert_document(source)
    self.assertEqual(pitch_number(notes(transposed)[0]['pitches'][0]), Fraction(125, 2))
    restored = self.round_trip(transposed)
    self.assertEqual(notes(restored)[0]['pitches'], notes(transposed)[0]['pitches'])
    unqualified = parse(xml_score(xml_note(alter='0.1')))
    self.assertEqual(fraction(notes(unqualified)[0]['pitches'][0]['alter']), Fraction(1, 10))
    layout = layout_score(unqualified, Style(), Fonts(Path('package/assets/fonts/petaluma')))
    self.assertTrue(any(p.role == 'accidental' and p.value == '(+1/10 st)' for page in layout.pages for p in page.primitives))
  def test_octave_shift_stop_at_a_bar_boundary_is_emitted_once(self):
    tree = ElementTree.fromstring(xml_score(xml_note()))
    ElementTree.SubElement(tree.find('part'), 'measure', number='2').append(ElementTree.fromstring(xml_note()))
    source = parse(ElementTree.tostring(tree, encoding='unicode'))
    source['staves'][0]['octave_shifts'] = [{'id': 'octave-1', 'start': rational(0), 'end': rational(4), 'octaves': 1}]
    restored = self.round_trip(source)
    self.assertEqual(source['staves'][0]['octave_shifts'], restored['staves'][0]['octave_shifts'])
  def test_unequal_chord_tones_are_retained_but_never_silently_flattened(self):
    source = parse(xml_score(xml_note() + xml_note('E', 2, 'half', prefix='<chord/>')))
    restored = self.round_trip(source)
    self.assertEqual(notes(restored)[0]['pitches'], notes(source)[0]['pitches'])
    layout = layout_score(source, Style(), Fonts(Path('package/assets/fonts/petaluma')))
    heads = [p.value for page in layout.pages for p in page.primitives if p.role == 'head']
    self.assertEqual(heads, ['noteheadWhole', 'noteheadHalf'])
  def test_overlapping_notes_within_one_voice_are_rejected(self):
    with self.assertRaisesRegex(ValueError, 'overlapping'):
      parse(xml_score(xml_note() + '<backup><duration>4</duration></backup>' + xml_note('E')))
  def test_multiple_lyric_verses_and_elisions_round_trip(self):
    lyrics = '<lyric number="1"><syllabic>begin</syllabic><text>one</text><elision> </elision><text>two</text><extend type="start"/></lyric>'
    lyrics += '<lyric number="2"><syllabic>single</syllabic><text>three</text></lyric>'
    source = parse(xml_score(xml_note(extra=lyrics)))
    restored = self.round_trip(source)
    self.assertEqual(notes(restored)[0]['lyrics'], notes(source)[0]['lyrics'])
  def test_percussion_and_tablature_are_semantic_not_pitch_guesses(self):
    percussion = '<note><unpitched><display-step>C</display-step><display-octave>5</display-octave></unpitched><duration>4</duration><type>whole</type><notehead>x</notehead></note>'
    source = parse(xml_score(percussion, attributes='<clef><sign>percussion</sign></clef>'))
    restored = self.round_trip(source)
    self.assertEqual(notes(restored)[0]['pitches'], notes(source)[0]['pitches'])
    with self.assertRaisesRegex(ValueError, 'authored TAB'):
      parse(xml_score(xml_note(), attributes='<clef><sign>TAB</sign></clef>'))
    for part in ('vocal', 'acoustic', 'electric'):
      with self.assertRaisesRegex(ValueError, 'pitched'):
        practice_document(source, part)
      with self.assertRaisesRegex(ValueError, 'pitched'):
        arrange_document(source, part)
  def test_percussion_instrument_definitions_round_trip_and_are_audited(self):
    tree = ElementTree.fromstring(xml_score('<note><unpitched><display-step>C</display-step><display-octave>5</display-octave></unpitched><duration>4</duration><instrument id="drum"/><type>whole</type></note>', attributes='<clef><sign>percussion</sign></clef>'))
    definition = tree.find('part-list/score-part')
    definition.append(ElementTree.fromstring('<score-instrument id="drum"><instrument-name>Snare</instrument-name><instrument-sound>drum.snare-drum</instrument-sound><solo/><virtual-instrument><virtual-name>Kit</virtual-name></virtual-instrument></score-instrument>'))
    definition.append(ElementTree.fromstring('<midi-instrument id="drum"><midi-channel>10</midi-channel><midi-unpitched>39</midi-unpitched></midi-instrument>'))
    source = parse(ElementTree.tostring(tree, encoding='unicode'))
    self.assertEqual(self.round_trip(source)['staves'][0]['instruments'], source['staves'][0]['instruments'])
    changed = copy.deepcopy(source)
    changed['staves'][0]['instruments'][0]['midi']['midi-unpitched'] = '40'
    with tempfile.TemporaryDirectory() as temporary:
      before, after = Path(temporary) / 'source.xml', Path(temporary) / 'output.xml'
      write_musicxml(before, source)
      write_musicxml(after, changed)
      with self.assertRaisesRegex(ValueError, 'percussion instrument'):
        audit_roundtrip(before, after)
    source['staves'][0]['instruments'] = []
    with self.assertRaisesRegex(ValueError, 'unknown score instrument'):
      validate_document(source)
  def test_catalog_roundtrip_preserves_written_pitch_and_rhythm(self):
    for path in sorted(path for category in ('practice', 'songs') for path in (Path('data') / category).glob('*.xml')):
      with self.subTest(path=path):
        source = load_musicxml(path)
        restored = self.round_trip(source)
        a, b = source['staves'][0]['measures'], restored['staves'][0]['measures']
        self.assertEqual(len(a), len(b))
        for original, result in zip(a, b):
          self.assertEqual(original['duration'], result['duration'])
          for v, w in zip(original['voices'], result['voices']):
            self.assertEqual(v['notes'], w['notes'])
  def test_missing_font_does_not_produce_a_bundle(self):
    with tempfile.TemporaryDirectory() as temporary:
      root = Path(temporary)
      source = parse(xml_score(xml_note()))
      path = root / 'fixture.json'
      path.write_text(json.dumps(source))
      with self.assertRaisesRegex(EngravingError, 'cannot load bundled'):
        engrave_tree(root, root / 'missing-fonts')
      self.assertEqual(json.loads(path.read_text()), source)
  def test_blank_and_wrong_sized_pages_are_rejected(self):
    from PIL import Image
    with tempfile.TemporaryDirectory() as temporary:
      path = Path(temporary) / 'page.png'
      for size in ((976, 484), (100, 100)):
        Image.new('RGB', size, 'white').save(path)
        with self.assertRaises(EngravingError):
          check_page(path)
  def test_audit_rejects_an_engraver_pitch_change(self):
    with tempfile.TemporaryDirectory() as temporary:
      source, output = Path(temporary) / 'source.xml', Path(temporary) / 'output.xml'
      source.write_text(xml_score(xml_note()))
      output.write_text(xml_score(xml_note('D')))
      with self.assertRaisesRegex(ValueError, 'pitch letter'):
        audit_roundtrip(source, output)
  def test_audit_rejects_staff_details_and_barline_changes(self):
    with tempfile.TemporaryDirectory() as temporary:
      source, output = Path(temporary) / 'source.xml', Path(temporary) / 'output.xml'
      document = parse(xml_score(xml_note()))
      for field, value in (('staff_details', {'lines': 6, 'tunings': []}), ('barlines', {'right': 'light-light'})):
        with self.subTest(field=field):
          original = copy.deepcopy(document)
          original['staves'][0]['measures'][0][field] = value
          write_musicxml(source, original)
          write_musicxml(output, document)
          with self.assertRaisesRegex(ValueError, 'engraver changed musical content'):
            audit_roundtrip(source, output)
  def test_audit_rejects_relocated_tuplet_brackets(self):
    modulation = '<time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>'
    source = parse(xml_score(''.join(xml_note(duration=2, kind='quarter', extra=modulation) for _ in range(6)), divisions=3))
    span = {'id': 'tuplet-1', 'voice': '1', 'start': notes(source)[0]['id'], 'end': notes(source)[2]['id'], 'note_count': 3, 'space_count': 2, 'depth': 0, 'bracket': 'auto', 'show_number': 'actual'}
    source['staves'][0]['tuplets'] = [span]
    for note in notes(source)[:3]:
      note['tuplet_ids'] = ['tuplet-1']
    changed = copy.deepcopy(source)
    changed['staves'][0]['tuplets'][0].update(start=notes(changed)[3]['id'], end=notes(changed)[5]['id'])
    for index, note in enumerate(notes(changed)):
      note['tuplet_ids'] = ['tuplet-1'] if index >= 3 else []
    with tempfile.TemporaryDirectory() as temporary:
      before, after = Path(temporary) / 'source.xml', Path(temporary) / 'output.xml'
      write_musicxml(before, source)
      write_musicxml(after, changed)
      with self.assertRaisesRegex(ValueError, 'members'):
        audit_roundtrip(before, after)
  def test_bundle_validation_checks_pages_and_rejects_symlink_escape(self):
    with tempfile.TemporaryDirectory() as temporary:
      root = Path(temporary)
      assets = root / 'assets'
      assets.mkdir()
      data = Path('tests/fixtures/engraving.png').read_bytes()
      page = assets / 'page.png'
      page.write_bytes(data)
      document = load_musicxml(Path('tests/fixtures/engraving.xml'))
      bundle = {'music': document, 'presentation': {'engine': ENGINE_NAME, 'width': 976, 'height': 484, 'pages': [{'path': 'page.png', 'sha256': hashlib.sha256(data).hexdigest()}]}}
      path = assets / 'score.json'
      path.write_text(json.dumps(bundle))
      self.assertEqual(load_json(path), document)
      page.write_bytes(data + b'corrupt')
      with self.assertRaisesRegex(ValueError, 'checksum'):
        load_json(path)
      page.unlink()
      outside = root / 'outside.png'
      outside.write_bytes(data)
      page.symlink_to(outside)
      with self.assertRaisesRegex(ValueError, 'escapes'):
        load_json(path)
  def test_python_engraver_visual_golden_and_determinism(self):
    from PIL import Image, ImageChops
    from generator.score import write_json
    document = load_musicxml(Path('tests/fixtures/engraving.xml'))
    with tempfile.TemporaryDirectory() as temporary:
      root = Path(temporary)
      before = None
      for _ in range(2):
        write_json(root / 'fixture.json', document)
        engrave_tree(root, Path('package/assets/fonts/petaluma'))
        bundle = json.loads((root / 'fixture.json').read_text())
        self.assertEqual(bundle['music'], document)
        self.assertEqual(len(bundle['presentation']['pages']), 1)
        page = root / bundle['presentation']['pages'][0]['path']
        with Image.open(page) as actual, Image.open('tests/fixtures/engraving-python.png') as expected:
          self.assertIsNone(ImageChops.difference(actual.convert('RGB'), expected.convert('RGB')).getbbox())
        if before is not None:
          self.assertEqual(bundle, before)
        before = bundle