import {
  ArghoTuningContext,
  defaultArghotunTranslations,
  TuningJsonParser,
} from '@arghotuning/arghotun';

const arghoContext = new ArghoTuningContext({
  translations: defaultArghotunTranslations(),
});
const parser = new TuningJsonParser(arghoContext);

try {
  const parseResult = parser.parseJsonString(inputJsonString);
  if (parseResult.warnings.length >= 1) {
    // Some file content wasn't understood. Display warnings[] to user that
    // this tuning may not have been interpreted fully.
  }
  const tuning = parseResult.tuning;
} catch (err) {
  // Input file was invalid; show err.message to user...
}

import {TuningJsonSerializer} from 'arghotun';

const serializer = new TuningJsonSerializer(arghoContext);
const outputJsonString = serializer.serializeToString(tuning);

const quarterToneTuning =
    Tuning.defaultNtet(arghoContext, 'My 24-TET Tuning', 24);
const defaultTuning =
    Tuning.default12tet(arghoContext, 'My 12-TET Tuning');

const metadata = tuning.getMetadata();  // See below.

const scale = tuning.getScale();
const mapping = tuning.getMapping();

// Add 3 additional degrees; each defaults to a 1:1 ratio (unison)
// measured from the root, without affecting any existing scale
// degrees. Newly added degrees are NOT mapped.
scale.addDegreesToEnd(3);

// Remove the last (by scale degree index) 3 degrees from the end
// of the scale. Any remaining scale degrees that were measured
// from the removed degrees will be updated to "skip over" the
// removed degrees, while preserving their existing tunings. Any
// input keys that were mapping to removed scale degrees are set
// to unmapped, leaving keySpan unchanged.
scale.removeDegreesFromEnd(3);

// Reset scale and mapping back to a 24-tone equal temperament
// scale and 1:1 key mapping, keeping the currently configured
// scale root and mapping root MIDI pitch. Also does not change
// other existing metadata (e.g. name, description).
scale.resetToDefaultNtet(24);

const name = metadata.getName();
metadata.setName('Updated Tuning Name');

const description = metadata.getDescription();  // '' if none.
metadata.setDescription('Description of the tuning');

const accidentalPref = metadata.getDisplayAccidentalsAs();
if (accidentalPref === AccidentalDisplayPref.SHARPS) {
  // Display any pitch names that need accidentals with sharps...
} else {
  // Display any pitch names that need accidentals with flats...
}
metadata.setDisplayAccidentalsAs(AccidentalDisplayPref.FLATS);

const numDegrees = scale.getNumDegrees();
const octavesSpanned = scale.getOctavesSpanned();  // See spec for details.

const root = scale.getRoot();  // Immutable.
scale.setRoot(updatedRoot);  // Replaces old value.

const deg3 = scale.getUpperDegree(2);  // Immutable.
const index = deg3.scaleDegreeIndex;  // 2.
const measureFromIndex = deg3.measureFromIndex;
const interval = deg3.tunedInterval;

// Replace old TunedInterval:
scale.setUpperDegreeTuning(2, updatedTunedInterval);

// Measure 3rd scale degree from 6th degree:
scale.setMeasureFromIndex(2, 5);

const limits = scale.getTuningLimitsForUpperDegree(2);
scale.setUpperDegreeTuning(2, limits.ensureWithin(userInputInterval));

const intervalFromDeg3ToRoot = scale.getIntervalFromSourceToDest(2, 0);

const up123Dot45Cents = TunedInterval.fromCents(arghoContext, 123.45);
const downPure5th = TunedInterval.fromRatio(arghoContext, 2, 3);

if (interval.getSpecType() === TunedIntervalSpecType.CENTS) {
  // User specified interval in cents...
} else {
  // User specified interval as a frequency ratio...
}

// Regardless of how it was specified, all of these accessors will always
// yield values:
const cents = interval.getCents();
const numerator = interval.getRatioNumerator();
const denominator = interval.getDenominator();  // Defaults to 1.

const upPure5th = downPure5th.inverse();  // Returns new immutable value.
const upPure9th = upPure5th.plus(upPure5th);  // (Ditto).

const defaultMiddleCRoot = RootScaleDegree.default(arghoContext);

const tuningA4Hz = 442.0;
const root234Dot5Hz =
    RootScaleDegree.exact(arghoContext, tuningA4Hz, 234.5);
const root12Dot3CentsBelowMiddleC =
    RootScaleDegree.relative(arghoContext, tuningA4Hz, 60, -12.3);

const globalTuneA4Hz = root.getGlobalTuneA4Hz();
if (root.getSpecType() === RootScaleDegreeSpecType.EXACT_FREQ) {
  // User specified root as an exact sounding frequency in Hz...
} else {
  // User specified root as cents +/- offset relative to 12-TET pitch...
}

// Regardless of how it was specified, all of these accessors will always
// yield values:
const rootFreqHz = root.getFreqHz();
const nearestMidiPitch = root.getNearestMidiPitch();
const centsFromNearestMidiPitch = root.getCentsFrom12tet();

const keySpan = mapping.getKeySpan();
mapping.setKeySpan(24);  // Any new keys start out unmapped.

const mappingRootMidiPitch = mapping.getRootMidiPitch();

// Set to mapping root to D above middle C. Doesn't affect scale.
mapping.setRootMidiPitch(62);

const mappedDegreeIndex = mapping.getMappedScaleDegreeIndexOrNull(5);
if (mappedDegreeIndex == null) {
  // Key isn't mapped to anything (don't produce any sound)...
} else {
  // Mapped to a scale degree...
}

// When 6th key is played, play 3rd scale degree.
mapping.setMappedScaleDegreeIndex(5, 2);

// When 4th key is played, play the scale root.
mapping.setMappedScaleDegreeIndex(3, 0);

// When 3rd key is played, don't play any scale degree (unmap).
mapping.setMappedScaleDegree(2, null);

const keyToSoundMap = KeyToSoundMap.calcFor(arghoContext, tuning);

function handleNoteOn(inputMidiPitch) {
  if (keyToSoundMap.isMapped(inputMidiPitch)) {
    const soundingScaleDegree = keyToSoundMap.mappedSoundFor(inputMidiPitch);
    playSoundWith(soundingScaleDegree.freqHz);

    // Can also access, if needed:
    // - soundingScaleDegree.scaleDegreeIndex
    // - soundingScaleDegree.octaveOffset (# octaves sounding away from "main" scale)
  } else {
    // Unmapped: drop this note (no output scale degree for it).
  }
}