"""Export auditions from completed assets; this command never composes music."""
from __future__ import annotations
import argparse
import array
import copy
import dataclasses
import html
import json
from pathlib import Path
from fractions import Fraction as F
from generator import model, musicxml_writer, playback, score
from generator.solo import notation, placement, types, similarity
from generator.solo.audition import excerpt, mix


def region(document, part):
  measures=document['staves'][0]['measures']
  first=next(i for i,m in enumerate(measures) if m.get('section_label')==part.capitalize()+' Solo')
  finish=next((i for i in range(first+1,len(measures)) if measures[i].get('section_label')),len(measures))
  return first,finish-first


def staged(document, details, stage, tempo):
  notes=[]
  for phrase in details['phrases']:
    for n in phrase['lead_stages'].get(stage,{}).get('notes',[]):
      p=n['pitch']
      notes.append(types.Note(F(n['start']),F(n['end']),types.Pitch(p['letter'],F(p['alter']),p['octave']),
        tuple(n['sources']),n['role'],continuation=n['continuation'],event_id=n['event_id']))
  notes=types.sounding_notes(tuple(notes))
  placed=placement.place(notes,tempo)
  if notes and placed is None:raise ValueError(stage+': no legal audition placement')
  result=copy.deepcopy(document)
  notation.replace_region(result,0,notation.measures(result['staves'][0]['measures'],placed[1] if placed else (),stage))
  model.validate_document(result)
  return result


def overlap(lead, backing):
  a=playback.compile_timeline(lead)['events'];b=playback.compile_timeline(backing)['events']
  total=covered=above=0.
  for n in a:
    start=model.fraction(n['onset']);end=start+model.fraction(n['duration']);pitch=model.fraction(n['pitch'])
    cuts={start,end}
    for other in b:
      s=model.fraction(other['onset']);e=s+model.fraction(other['duration'])
      if s<end and e>start:cuts.update((max(s,start),min(e,end)))
    points=sorted(cuts)
    for x,y in zip(points,points[1:]):
      simultaneous=[o for o in b if model.fraction(o['onset'])<=x<model.fraction(o['onset'])+model.fraction(o['duration'])]
      total+=float(y-x)
      if simultaneous:covered+=float(y-x)
      if any(model.fraction(o['pitch'])>pitch for o in simultaneous):above+=float(y-x)
  return {'sounding_beats':total,'backing_overlap_fraction':covered/max(.001,total),'backing_above_lead_fraction':above/max(.001,total),
    'interpretation':'score overlap only; not a perceptual masking measurement; no feedback to composition'}


def export(assets,baseline,output):
  output.mkdir(parents=True,exist_ok=True)
  manifest={'composition_inputs':False,'gain':.65,'backing_gain':.55,'playback':'unchanged neutral constant-level synthesis',
    'listening_status':'not auditioned by the agent; score validation and rendered signal checks only','solos':{}}
  tone_cache={};clips=[];notes_report=[]
  for roles_path in sorted((assets/'analysis').glob('*.roles')):
    song=roles_path.stem;roles=json.loads(roles_path.read_text())
    for part in ('acoustic','electric'):
      print('Audition: '+song+'/'+part,flush=True)
      other='electric' if part=='acoustic' else 'acoustic'
      assembled=score.load_json(assets/'songs'/f'{song}_{part}.json')
      backing=score.load_json(assets/'songs'/f'{song}_{other}.json')
      first,count=region(assembled,part)
      lead=excerpt(assembled,first,count);backing=excerpt(backing,first,count)
      detail=roles[part+'_solo']['details']
      tempo=next((model.fraction(t['bpm'])*model.written_length(t['written']) for m in assembled['staves'][0]['measures'] for t in m.get('tempos',[]) if 'bpm' in t),F(120))
      versions={'final':lead, 'plain':staged(lead,detail,'refined',tempo), 'strict':staged(lead,detail,'before_enclosure',tempo), 'source':staged(lead,detail,'initial',tempo)}
      baseline_backing=None
      old=baseline/'songs'/f'{song}_{part}.json' if baseline else None
      if old and old.is_file():
        original=score.load_json(old);a,b=region(original,part)
        versions['baseline']=excerpt(original,a,b)
        baseline_backing=excerpt(score.load_json(baseline/'songs'/f'{song}_{other}.json'),a,b)
      key=song+'_'+part
      manifest['solos'][key]={'tempo':str(tempo),'source_form_measures':count,'details':detail,
        'input_trace':roles[part+'_solo']['trace'],'ensemble':overlap(lead,backing)}
      notes_report.append(key+' — solo-relative rational quarter-note time; sounding pitches\n')
      for phrase in detail['phrases']:
        notes_report.append(f"{phrase['id']}: {phrase['start']}–{phrase['end']}; {phrase['ending']}; completed={phrase['ending_completed']}\n")
        for n in phrase['draft']['notes']:
          p=n['pitch'];tone=types.Pitch(p['letter'],F(p['alter']),p['octave'])
          pos=n['position'];notes_report.append(f"  {n['start']}–{n['end']} {tone.label()} {n['role']} string {pos[0]} fret {pos[1]}\n")
      back_audio=mix([backing],tempo,output,tone_cache)
      for name,document in versions.items():
        label=key+'_'+name
        score.write_json(output/(label+'.json'),document)
        musicxml_writer.write_musicxml(output/(label+'.xml'),document)
        solo_audio=mix([document],tempo,output,tone_cache)
        combined=array.array('f',(v+.55*(back_audio[i] if i<len(back_audio) else 0) for i,v in enumerate(solo_audio)))
        variants={'solo':solo_audio,'fixed_backing':combined}
        if name=='final':variants['final_arrangement']=combined
        if name=='baseline' and baseline_backing:
          oldback=mix([baseline_backing],tempo,output,tone_cache)
          variants['original_backing']=array.array('f',(v+.55*(oldback[i] if i<len(oldback) else 0) for i,v in enumerate(solo_audio)))
        for context,values in variants.items():
          peak=max(map(abs,values),default=0)*manifest['gain']
          if peak>=1:raise ValueError('Audition gain would clip; choose a lower shared gain')
          path=label+'_'+context+'.wav'
          playback.write_pcm(output/path,(v*manifest['gain'] for v in values))
          clips.append({'file':path,'song':song,'part':part,'version':name,'context':context,'peak':peak})
          if context=='fixed_backing':
            # Exact slices retain the same backing and gain. Counts come from
            # the completed source form, not a presumed 32-bar chorus.
            measures=document['staves'][0]['measures'];durations=[model.fraction(m['duration']) for m in measures]
            for excerpt_name,start,end in (('opening',F(),sum(durations[:8],F())),('ending',sum(durations[:-4],F()),sum(durations,F()))):
              factor=F(60*playback.SAMPLE_RATE)/tempo
              selection=values[round(start*factor):round(end*factor)]
              clip=label+'_'+excerpt_name+'.wav'
              playback.write_pcm(output/clip,(v*manifest['gain'] for v in selection))
              clips.append({'file':clip,'song':song,'part':part,'version':name,'context':excerpt_name,'peak':peak})
  manifest['pair_comparisons']={}
  for song in sorted({c['song'] for c in clips}):
    def events(part):
      detail=manifest['solos'][song+'_'+part]['details']
      return tuple((float(F(n['start'])),float(F(n['end'])),types.Pitch(n['pitch']['letter'],F(n['pitch']['alter']),n['pitch']['octave']).number())
        for p in detail['phrases'] for n in p['draft']['notes'])
    manifest['pair_comparisons'][song]=similarity.compare_events(events('electric'),events('acoustic'))
  manifest['clips']=clips
  (output/'report.json').write_text(json.dumps(manifest,indent=2))
  (output/'notes.txt').write_text(''.join(notes_report))
  rows=['<!doctype html><meta charset="utf-8"><title>Independent generation auditions</title><style>body{max-width:1100px;margin:2rem auto;font:16px system-ui}audio{width:420px}td{padding:.5rem}details{margin:1rem}</style>',
    '<h1>Independent generation auditions</h1><p>Baseline and new music, same neutral rendering and fixed comparison backing. All files share gain 0.65; backing gain 0.55. Final arrangements use the new independent canonical backing. No subjective listening verdict has been made.</p><p><a href="report.json">Full roles, contracts and diagnostics</a> · <a href="notes.txt">Sounding note report</a></p>']
  for key,detail in manifest['solos'].items():
    rows.append('<h2>'+html.escape(key)+'</h2><table>')
    for c in clips:
      if c['song']+'_'+c['part']!=key:continue
      label=c['version']+' / '+c['context']
      rows.append('<tr><td>'+html.escape(label)+'</td><td><audio controls preload="none" src="'+c['file']+'"></audio></td><td><a href="'+c['file']+'">WAV</a></td></tr>')
    rows.append('</table>')
  (output/'index.html').write_text('\n'.join(rows))


def main():
  p=argparse.ArgumentParser(description=__doc__)
  p.add_argument('--assets',type=Path,required=True);p.add_argument('--baseline',type=Path);p.add_argument('--output',type=Path,required=True)
  args=p.parse_args();export(args.assets,args.baseline,args.output)

if __name__=='__main__':main()