from __future__ import annotations

import json
import pathlib
import typing

import generator.model
import generator.score
import generator.score_io

def _arranged_staff(document: dict[str, typing.Any]) -> dict[str, typing.Any]:
  staves = document.get("staves")
  if not isinstance(staves, list) or not staves or not isinstance(staves[0], dict):
    raise ValueError("generated score document must contain an arranged staff")
  return staves[0]

def _measure_summary(staff: dict[str, typing.Any], measure: dict[str, typing.Any], measure_number: int) -> dict[str, typing.Any]:
  notes = generator.score.measure_notes(measure)
  summary: dict[str, typing.Any] = {
    "measure": measure_number,
    "section_label": str(measure.get("section_label", "")),
    "harmonies": [{"onset": str(generator.model.fraction(h["onset"])), "symbol": h["symbol"]} for h in measure["harmonies"]],
    "duration": str(generator.model.fraction(measure["duration"])),
    "slash_count": sum(1 for note in notes if note.get("kind", "note") == "note" and note.get("notehead") == "slash"),
  }
  if staff.get("arrangement_part_type") == "vocal":
    summary["vocal_skeleton"] = [
      f'{generator.model.fraction(note["onset"])}+{generator.model.fraction(note["duration"])} '
      + note['written']['type'] + '.' * note['written'].get('dots', 0)
      + ' ' + note['kind'] + ' ' + ','.join(generator.model.pitch_name(p) + str(p['octave']) for p in note['pitches'])
      + ' ' + note.get('lyric', '')
      for note in notes
    ]
  return summary

def performance_document_summary(document: dict[str, typing.Any]) -> dict[str, typing.Any]:
  metadata = document.get("metadata")
  if not isinstance(metadata, dict):
    metadata = {}
  staff = _arranged_staff(document)
  measures = staff.get("measures")
  if not isinstance(measures, list):
    measures = []
  measure_summaries = [
    _measure_summary(staff, measure, index + 1)
    for index, measure in enumerate(measures)
    if isinstance(measure, dict)
  ]
  return {
    "title": str(metadata.get("title", "")),
    "composer": str(metadata.get("composer", "")),
    "key_signature": str(metadata.get("key_signature", "")),
    "part_type": str(staff.get("arrangement_part_type", "")),
    "measure_count": len(measure_summaries),
    "section_labels": [
      {"measure": item["measure"], "label": item["section_label"]}
      for item in measure_summaries
      if item["section_label"]
    ],
    "measures": measure_summaries,
  }

def performance_tree_summary(root: pathlib.Path) -> dict[str, typing.Any]:
  return {
    path.name: performance_document_summary(generator.score_io.load_json(path))
    for path in sorted(root.glob("*.json"))
  }

def validate_expected_performance_summary(expected_path: pathlib.Path, generated_songs_dir: pathlib.Path) -> None:
  if not expected_path.exists():
    raise ValueError(f"missing generator compatibility summary: {expected_path}")
  with expected_path.open("r", encoding="utf-8") as stream:
    expected = json.load(stream)
  actual = performance_tree_summary(generated_songs_dir)
  if actual == expected:
    return
  expected_names = set(expected.keys()) if isinstance(expected, dict) else set()
  actual_names = set(actual.keys())
  missing = sorted(expected_names - actual_names)
  extra = sorted(actual_names - expected_names)
  if missing or extra:
    raise ValueError(f"performance generator drift: missing={missing}, extra={extra}")
  for name in sorted(actual_names):
    if actual[name] != expected[name]:
      raise ValueError(f"performance generator drift in {name}; update generator logic or refresh the expected summary intentionally")
  raise ValueError("performance generator drift")