package com.github.dakusui.symfonion.song;

import com.github.dakusui.symfonion.compat.exceptions.SymfonionException;

import com.github.dakusui.symfonion.compat.exceptions.SymfonionIllegalFormatException;

import com.github.dakusui.symfonion.compat.json.*;

import com.github.dakusui.symfonion.core.MidiCompiler;

import com.github.dakusui.symfonion.core.MidiCompilerContext;

import com.github.dakusui.symfonion.utils.Fraction;

import com.github.dakusui.symfonion.utils.Utils;

import com.google.gson.*;

import javax.sound.midi.InvalidMidiDataException;

import javax.sound.midi.MidiEvent;

import javax.sound.midi.Track;

import java.util.LinkedList;

import java.util.List;

import java.util.Optional;

import java.util.regex.Matcher;

import static com.github.dakusui.symfonion.compat.exceptions.CompatExceptionThrower.*;

import static com.github.dakusui.symfonion.compat.exceptions.SymfonionIllegalFormatException.NOTE_LENGTH_EXAMPLE;

import static com.github.dakusui.symfonion.compat.exceptions.SymfonionTypeMismatchException.PRIMITIVE;

import static com.github.dakusui.symfonion.compat.json.CompatJsonUtils.asJsonArrayWithDefault;

import static com.github.dakusui.symfonion.compat.json.CompatJsonUtils.asStringWithDefault;

import static com.github.dakusui.symfonion.utils.Fraction.ZERO;

import static com.github.valid8j.fluent.Expectations.*;

/**

 * A class that models a measure of a part.

*/

public class PartMeasure {

  public static final  java.util.regex.Pattern NOTE_LENGTH_REGEX_PATTERN

                                                                   = java.util.regex.Pattern.compile("(?<num>[1-9][0-9]*)(?<dots>\\.*)(?<articulation>[~^']?)");

  private static final java.util.regex.Pattern NOTES_REGEX_PATTERN = java.util.regex.Pattern.compile("(?<noteName>[A-Zac-z])(?<accidentals>[#b]*)(?<octaveShifts>[><]*)(?<accents>[+\\-]*)?");

  private static final int                     UNDEFINED_NUM       = -1;

  private final        PartMeasureParameters   defaultValues;

  private final        double                  gate;

  private final        int[]                   volume;

  private final        int[]                   pan;

  private final        int[]                   reverb;

  private final        int[]                   chorus;

  private final        int[]                   pitch;

  private final        int[]                   modulation;

  private final        int                     pgno;

  private final        String                  bkno;

  private final        int                     tempo;

  private final        JsonArray               sysex;

  private final        int[]                   aftertouch;

  private final        StrokeSequence          strokeSequence;

/**

   * The ```partMeasureJson``` needs to be a JSON element which can promote to the following object

   * with ```CompatJsonUtils#asJsonArrayWithPromotion( JsonElement, Object...)```.

   * // @formatter:off

   * [source, JSON]

   * .partMeasureJson

   * ----

* {

   *   "notes": "<strokeSequence:array>",

   *   "length": "<length:string@{Fraction}>",

   *   "gate": "<gate:number@{double}>",

   *   "volume": "<volume:array@{int}>",

   *   "pan": "<pan:array@{int}>",

   *   "reverb": "<reverb:array@{int}>",

   *   "chorus": "<chorus:array@{int}>",

   *   "modulation": "<modulation:array@{int}>",

   *   "aftertouch": "<aftertouch:array@{int}>",

   *   "sysex": "<sysex:array@{int}>"

* }

   * ----

   * If it doesn't have a corresponding element, it will be considered `null` is specified.

   * The **NOTES String** should match the following regular expression or such strings concatenated by `;`.

   * `([A-Zac-z])([#b]*)([><]*)([\\+\\-]*)?`

   * That is, the data this class host is actually a sequence of strokes, not merely a stroke.

   * Historical reason introduced this naming inconsistency.

   * // Using `@see` at the bottom of this comment will break `mvn javadoc:javadoc` for unknown reason.

   * See also {@code Pattern.Parameters} and {@code CompatJsonUtils#asJsonArrayWithDefault(JsonElement, JsonArray, Object...)}.

   * // @formatter:on

   * @param partMeasureJson A JSON object to be interpreted as a stroke.

   * @param params Default values of strokes when omitted.

   * @throws SymfonionException Failed to process `partMeasureJson`.

   * @throws CompatJsonException Failed to interpret `partMeasureJson`.

*/

  public PartMeasure(JsonElement partMeasureJson, PartMeasureParameters params) throws SymfonionException, CompatJsonException {

    this(CompatJsonUtils.asJsonObjectWithPromotion(partMeasureJson, new String[]{Keyword.notes.name(), Keyword.length.name()}), params);

  public PartMeasure(JsonObject obj, PartMeasureParameters defaultValues) throws SymfonionException, CompatJsonException {

1 1. <init> : negated conditional → KILLED

    this.tempo          = CompatJsonUtils.hasPath(obj, Keyword.tempo) ? CompatJsonUtils.asInt(obj, Keyword.tempo) : UNDEFINED_NUM;

1 1. <init> : negated conditional → KILLED

    this.pgno           = CompatJsonUtils.hasPath(obj, Keyword.program) ? CompatJsonUtils.asInt(obj, Keyword.program) : UNDEFINED_NUM;

    this.bkno           = resolveBankNumber(obj);

100

    this.volume         = getIntArray(obj, Keyword.volume);

101

    this.pan            = getIntArray(obj, Keyword.pan);

102

    this.reverb         = getIntArray(obj, Keyword.reverb);

103

    this.chorus         = getIntArray(obj, Keyword.chorus);

104

    this.pitch          = getIntArray(obj, Keyword.pitch);

105

    this.modulation     = getIntArray(obj, Keyword.modulation);

106

    this.aftertouch     = getIntArray(obj, Keyword.aftertouch);

107

    this.sysex          = asJsonArrayWithDefault(obj, null, Keyword.sysex);

108

    this.gate           = resolveGate(obj, defaultValues);

109

    this.strokeSequence = parseStrokeSequence(asStringWithDefault(obj, null, Keyword.notes),

110

                                              resolveDefaultStrokeLength(obj, defaultValues),

111

                                              defaultValues.noteMap);

112

    this.defaultValues  = defaultValues;

113

114

115

/**

116

   * Compiles this object using a given `compiler` and store its result in the `context`.

117

118

   * @param compiler A compiler with which this object is processed.

119

   * @param context  A context in which the compiled result is stored.

120

   * @throws InvalidMidiDataException Failed to generate MIDI data.

121

*/

122

  public void compile(final MidiCompiler compiler, MidiCompilerContext context) throws InvalidMidiDataException {

123

    final Track track = context.track();

124

    final int   ch    = context.channel();

125

    long absolutePosition = convertRelativePositionInPartMeasureToAbsolutePositionInTicks(context,

126

                                                                                          ZERO);

127

    long partMeasureLength = calculatePartMeasureLengthInTicks(this, context);

128

1 1. compile : negated conditional → KILLED

    if (tempo != UNDEFINED_NUM) {

129

      track.add(compiler.createTempoEvent(this.tempo, absolutePosition));

130

1 1. compile : removed call to com/github/dakusui/symfonion/core/MidiCompiler::controlEventProcessed → NO_COVERAGE

      compiler.controlEventProcessed();

131

132

1 1. compile : negated conditional → KILLED

    if (bkno != null) {

133

      int msb = Integer.parseInt(bkno.substring(0, this.bkno.indexOf('.')));

134

      track.add(compiler.createBankSelectMSBEvent(ch, msb, absolutePosition));

135

1 1. compile : negated conditional → KILLED

      if (this.bkno.indexOf('.') != -1) {

136

1 1. compile : Replaced integer addition with subtraction → KILLED

        int lsb = Integer.parseInt(bkno.substring(this.bkno.indexOf('.') + 1));

137

        track.add(compiler.createBankSelectLSBEvent(ch, lsb, absolutePosition));

138

139

1 1. compile : removed call to com/github/dakusui/symfonion/core/MidiCompiler::controlEventProcessed → SURVIVED

      compiler.controlEventProcessed();

140

141

1 1. compile : negated conditional → KILLED

    if (pgno != UNDEFINED_NUM) {

142

      track.add(compiler.createProgramChangeEvent(ch, this.pgno, absolutePosition));

143

1 1. compile : removed call to com/github/dakusui/symfonion/core/MidiCompiler::controlEventProcessed → SURVIVED

      compiler.controlEventProcessed();

144

145

1 1. compile : negated conditional → KILLED

    if (sysex != null) {

146

      MidiEvent ev = compiler.createSysexEvent(ch, sysex, absolutePosition);

147

1 1. compile : negated conditional → NO_COVERAGE

      if (ev != null) {

148

        track.add(ev);

149

1 1. compile : removed call to com/github/dakusui/symfonion/core/MidiCompiler::sysexEventProcessed → NO_COVERAGE

        compiler.sysexEventProcessed();

150

151

152

1 1. compile : removed call to com/github/dakusui/symfonion/song/PartMeasure::renderArrayedValues → KILLED

    renderArrayedValues(volume, absolutePosition, partMeasureLength, compiler, (v, pos) -> track.add(compiler.createVolumeChangeEvent(ch, v, pos)));

153