import copy
from fractions import Fraction
import hashlib
import json
import os
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.engraving import EngravingError, check_page, engrave_tree, qualify
from generator.engraving.audit 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.transposition import transpose_document
from tests.test_musicxml import notes, parse, xml_note, xml_score

class ScoreBundleTests(unittest.TestCase):
  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_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, practice_document(source), transpose_document(source, 'D'), 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_microtones_remain_exact_after_transposition_and_export(self):
    source = parse(xml_score(xml_note(alter='0.5', extra='<accidental>quarter-sharp</accidental>')))
    transposed = transpose_document(source, 'D')
    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))
    with self.assertRaisesRegex(EngravingError, 'microtonal'):
      qualify(unqualified)
  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'])
    with self.assertRaisesRegex(EngravingError, 'independently sustained'):
      qualify(source)
  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'])
    tab = parse(xml_score(xml_note(extra='<notations><technical><string>2</string><fret>1</fret></technical></notations>'), attributes='<clef><sign>TAB</sign><line>5</line></clef><staff-details><staff-lines>6</staff-lines></staff-details>'))
    self.assertEqual(notes(self.round_trip(tab))[0]['pitches'], notes(tab)[0]['pitches'])
    for document in (source, tab):
      validate_document(practice_document(document))
      for part in ('vocal', 'acoustic', 'electric'):
        with self.assertRaisesRegex(ValueError, 'conversion is not qualified'):
          arrange_document(document, 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_catalogue_roundtrip_preserves_written_pitch_and_rhythm(self):
    for path in Path('data').rglob('*.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_wrong_engine_version_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 patch.dict(os.environ, {'VAMP_MUSESCORE': '/engine'}), patch('generator.engraving.run_engine', return_value='MuseScore 3.6'):
        with self.assertRaisesRegex(EngravingError, 'expected MuseScore'):
          engrave_tree(root, Path('package/assets/fonts/petaluma'))
      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 = {'schema_version': 3, 'music': {k: v for k, v in document.items() if k != 'schema_version'}, 'presentation': {'engine': 'MuseScore Studio', 'engine_version': '4.7.4', '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)
  @unittest.skipUnless(os.environ.get('VAMP_MUSESCORE'), 'pinned engraver integration runs in the managed build image')
  def test_pinned_engine_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'], {k: v for k, v in document.items() if k != 'schema_version'})
        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.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