Three Dollar Quill

"""Data structures for representing note durations."""

import enum
import fractions
import typing


class NoteType(enum.Enum):
    """Enum of simple note values."""

    START = enum.auto()
    TIED = enum.auto()
    REST = enum.auto()

    def clap(self, beat_string: str) -> str:
        """Return the beat notation for this note type, given beat number."""
        if self == NoteType.START:
            return 'CLAP'
        elif self == NoteType.TIED:
            return beat_string
        assert self == NoteType.REST
        return f'({beat_string})'


class NoteDuration(typing.NamedTuple):
    """Class representing a single note as written."""

    base_duration: fractions.Fraction = fractions.Fraction(1)
    augmentation_dots: int = 0
    note_type: NoteType = NoteType.START

    @property
    def full_duration(self):
        """Return the duration of the note, after augmentation."""
        fraction_of_whole = self.base_duration
        fraction_to_add = fraction_of_whole
        for _ in range(self.augmentation_dots):
            fraction_to_add /= 2
            fraction_of_whole += fraction_to_add
        return fraction_of_whole

    def beats_as_written(self, beats_per_whole: int = 4) -> fractions.Fraction:
        """Return the number of beats in the note, given number in whole."""
        return self.full_duration * beats_per_whole

    @classmethod
    def per_whole(cls, beats_per_whole: int):
        """Return the note corresponding to given division of a whole note."""
        return cls(fractions.Fraction(1, beats_per_whole))

    def subdivide(
            self,
            beats_per_whole: int,
            offset: fractions.Fraction
    ) -> typing.Tuple[typing.List['NoteDuration'], fractions.Fraction]:
        """Convert this note into beat-aligned notes tied together."""
        notes = []
        duration = self.beats_as_written(beats_per_whole)
        remaining = fractions.Fraction(1) - offset
        first_duration = min(remaining, duration)
        notes.append(self._replace(  # pylint: disable=no-member
            base_duration=first_duration / beats_per_whole,
            augmentation_dots=0))
        if self.note_type == NoteType.REST:
            note_type = NoteType.REST
        else:
            note_type = NoteType.TIED
        offset += first_duration
        duration -= first_duration
        while duration:
            offset = min(offset, duration)
            notes.append(NoteDuration(
                base_duration=offset / beats_per_whole,
                note_type=note_type))
            duration -= offset
        if offset == 1:
            offset = fractions.Fraction()
        return notes, offset

    def as_tied(self):
        """Return this note, but tied to the previous note."""
        # pylint: disable=no-member
        return self._replace(note_type=NoteType.TIED)

    def as_rest(self):
        """Return this note, but as a rest."""
        # pylint: disable=no-member
        return self._replace(note_type=NoteType.REST)


BREVE = NoteDuration(fractions.Fraction(2))
WHOLE = NoteDuration()
# pylint doesn't know how classes work, sometimes.
HALF = NoteDuration.per_whole(2)  # pylint: disable=no-member
QUARTER = NoteDuration.per_whole(4)  # pylint: disable=no-member
EIGHTH = NoteDuration.per_whole(8)  # pylint: disable=no-member
SIXTEENTH = NoteDuration.per_whole(16)  # pylint: disable=no-member
THIRTY_SECOND = NoteDuration.per_whole(32)  # pylint: disable=no-member

DOTTED_HALF = HALF._replace(augmentation_dots=1)
DOTTED_QUARTER = QUARTER._replace(augmentation_dots=1)

"""Data structures for representing measures."""

import fractions
import typing

from . import note


class Measure(typing.NamedTuple):
    """Class representing a measure as a collection of notes."""

    notes: typing.Tuple[note.NoteDuration, ...]

    time_signature: typing.Tuple[int, int] = (4, 4)

    @property
    def is_valid(self) -> bool:
        """Return whether the notes given fit exactly into the measure."""
        beats_total, beats_per_whole = self.time_signature
        if sum(
                note.beats_as_written(beats_per_whole)
                for note in self.notes) != beats_total:
            return False
        for fst, snd in zip(self.notes, self.notes[1:]):
            if (fst.note_type == note.NoteType.REST) and (
                    snd.note_type == note.NoteType.TIED):
                return False
        return True

    @property
    def final_rest(self) -> bool:
        """Return whether the final note in the measure is a rest."""
        return self.notes[-1].note_type == note.NoteType.REST

    @property
    def initial_tie(self) -> bool:
        """Return whether the initial note in the measure is tied."""
        return self.notes[0].note_type == note.NoteType.TIED

    @property
    def notes_merged(self) -> "Measure":
        """Return a measure that sounds the same, but with the least notes."""
        notes = [self.notes[0]]
        for note_ in self.notes[1:]:
            last_note = notes[-1]
            if (note_.note_type == note.NoteType.TIED) or (
                    last_note.note_type == note.NoteType.REST
                    and note_.note_type == note.NoteType.REST):
                notes[-1] = note.NoteDuration(
                    last_note.full_duration + note_.full_duration,
                    note_type=last_note.note_type)
            else:
                notes.append(note_)
        return self._replace(notes=tuple(notes))  # pylint: disable=no-member

    @property
    def beat_separated(self) -> "Measure":
        """Return a measure that sounds the same, but with defined beats."""
        notes = []
        offset = fractions.Fraction()
        beats_per_whole = self.time_signature[1]
        for note_ in self.notes_merged.notes:
            new_notes, offset = note_.subdivide(beats_per_whole, offset)
            notes.extend(new_notes)
        return self._replace(notes=tuple(notes))  # pylint: disable=no-member

    def beats(self) -> typing.Iterator[typing.Tuple[note.NoteDuration, ...]]:
        """Yield each individual beat as a tuple of notes."""
        beat_target = fractions.Fraction(1, self.time_signature[1])
        beats = []
        for note_ in self.beat_separated.notes:
            beats.append(note_)
            if sum(note__.base_duration for note__ in beats) == beat_target:
                yield tuple(beats)
                beats = []

    def clap_strs(self) -> typing.Iterator[str]:
        """Yield the clap strings associated with the measure."""
        beats = tuple(self.beats())
        for beat, notes in enumerate(beats):
            beat += 1  # Account for indexing conventions
            realizations = []
            realizations.append(notes[0].note_type.clap(str(beat)))
            for note_ in notes[1:]:
                # Assume we only do half-divisions
                assert note_.beats_as_written(
                    self.time_signature[1]) == 0.5, notes
                realizations.append(note_.note_type.clap('and'))
            yield '-'.join(realizations)


class MultiMeasure(typing.NamedTuple):
    """Class representing several measures in sequence."""

    measures: typing.Tuple[Measure, ...]

    @property
    def is_valid(self) -> bool:
        """Return whether the overall collection of measures is valid."""
        for measure in self.measures:
            if not measure.is_valid:
                return False
        for fst, snd in zip(self.measures, self.measures[1:]):
            if fst.final_rest and snd.initial_tie:
                return False
        return True

    @property
    def clap_str(self) -> str:
        """Return the clap pattern for the measures."""
        accumulator: typing.List[str] = []
        for measure in self.measures:
            accumulator.extend(measure.clap_strs())
        return ' '.join(accumulator)