/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2021 Artyom Skrobov
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "py/runtime.h"
#include "shared-bindings/synthio/MidiTrack.h"

#define BITS_PER_SAMPLE (16)
#define BYTES_PER_SAMPLE (BITS_PER_SAMPLE / 8)
#define MAX_DUR (512)
#define SILENCE (0x80)


STATIC NORETURN void raise_midi_stream_error(uint32_t pos) {
    mp_raise_ValueError_varg(translate("Error in MIDI stream at position %d"), pos);
}

STATIC uint8_t parse_note(const uint8_t *buffer, uint32_t len, uint32_t *pos) {
    if (*pos + 1 >= len) {
        raise_midi_stream_error(*pos);
    }
    uint8_t note = buffer[(*pos)++];
    if (note > 127 || buffer[(*pos)++] > 127) {
        raise_midi_stream_error(*pos);
    }
    return note;
}

STATIC void terminate_span(synthio_miditrack_obj_t *self, uint16_t *dur) {
    if (*dur) {
        self->track[self->total_spans - 1].dur = *dur;
        *dur = 0;
    } else {
        self->total_spans--;
    }
}

STATIC void add_span(synthio_miditrack_obj_t *self, const synthio_midi_span_t *span) {
    self->track = m_renew(synthio_midi_span_t, self->track, self->total_spans, self->total_spans + 1);
    self->track[self->total_spans++] = *span;
}

STATIC int find_channel_with_note(const synthio_midi_span_t *span, uint8_t note) {
    for (int i = 0; i < CIRCUITPY_SYNTHIO_MAX_CHANNELS; i++) {
        if (span->note[i] == note) {
            return i;
        }
    }
    return -1;
}

STATIC void change_span_note(synthio_miditrack_obj_t *self, uint8_t old_note, uint8_t new_note, uint16_t *dur) {
    synthio_midi_span_t span = self->track[self->total_spans - 1];
    int channel = find_channel_with_note(&span, old_note);
    if (channel != -1) {
        terminate_span(self, dur);
        span.note[channel] = new_note;
        add_span(self, &span);
        *dur = 0;
    }
}

void common_hal_synthio_miditrack_construct(synthio_miditrack_obj_t *self,
    const uint8_t *buffer, uint32_t len, uint32_t tempo, uint32_t sample_rate,
    const int16_t *waveform, uint16_t waveform_length) {

    synthio_midi_span_t initial = { 0, {[0 ... (CIRCUITPY_SYNTHIO_MAX_CHANNELS - 1)] = SILENCE} };
    self->sample_rate = sample_rate;
    self->track = m_malloc(sizeof(synthio_midi_span_t), false);
    self->next_span = 0;
    self->total_spans = 1;
    *self->track = initial;
    self->waveform = waveform;
    self->waveform_length = waveform_length;
    mp_arg_validate_length_range(waveform_length, 2, 1024, MP_QSTR_waveform);

    uint16_t dur = 0;
    uint32_t pos = 0;
    while (pos < len) {
        uint8_t c;
        uint32_t delta = 0;
        do {
            c = buffer[pos++];
            delta <<= 7;
            delta |= c & 0x7f;
        } while ((c & 0x80) && (pos < len));

        if (c & 0x80) {
            raise_midi_stream_error(pos);
        }

        // dur is carried over here so that if a note on/off message doesn't actually produce a change, the
        // underlying "span" is extended. Otherwise, it is zeroed out in the call to `terminate_span`.
        dur += delta * sample_rate / tempo;

        switch (buffer[pos++] >> 4) {
            case 8: { // Note Off
                uint8_t note = parse_note(buffer, len, &pos);
                change_span_note(self, note, SILENCE, &dur);
                break;
            }
            case 9: { // Note On
                uint8_t note = parse_note(buffer, len, &pos);
                change_span_note(self, SILENCE, note, &dur);
                break;
            }
            case 10:
            case 11:
            case 14: // two data bytes to ignore
                parse_note(buffer, len, &pos);
                break;
            case 12:
            case 13: // one data byte to ignore
                if (pos >= len || buffer[pos++] > 127) {
                    raise_midi_stream_error(pos);
                }
                break;
            case 15: // the full syntax is too complicated, just assume it's "End of Track" event
                pos = len;
                break;
            default: // invalid event
                raise_midi_stream_error(pos);
        }
    }
    terminate_span(self, &dur);

    uint16_t max_dur = 0;
    for (int i = 0; i < self->total_spans; i++) {
        max_dur = MAX(self->track[i].dur, max_dur);
    }
    self->buffer_length = MIN(MAX_DUR, max_dur) * BYTES_PER_SAMPLE;
    self->buffer = m_malloc(self->buffer_length, false);
}

void common_hal_synthio_miditrack_deinit(synthio_miditrack_obj_t *self) {
    m_del(uint8_t, self->buffer, self->buffer_length);
    self->buffer = NULL;
    m_del(synthio_midi_span_t, self->track, self->total_spans + 1);
    self->track = NULL;
}
bool common_hal_synthio_miditrack_deinited(synthio_miditrack_obj_t *self) {
    return self->buffer == NULL;
}

uint32_t common_hal_synthio_miditrack_get_sample_rate(synthio_miditrack_obj_t *self) {
    return self->sample_rate;
}
uint8_t common_hal_synthio_miditrack_get_bits_per_sample(synthio_miditrack_obj_t *self) {
    return BITS_PER_SAMPLE;
}
uint8_t common_hal_synthio_miditrack_get_channel_count(synthio_miditrack_obj_t *self) {
    return 1;
}

void synthio_miditrack_reset_buffer(synthio_miditrack_obj_t *self,
    bool single_channel_output, uint8_t channel) {

    self->remaining_dur = 0;
    self->next_span = 0;
}

STATIC const uint16_t notes[] = {8372, 8870, 9397, 9956, 10548, 11175, 11840,
                                 12544, 13290, 14080, 14917, 15804}; // 9th octave

static int count_active_channels(synthio_midi_span_t *span) {
    int result = 0;
    for (int i = 0; i < CIRCUITPY_SYNTHIO_MAX_CHANNELS; i++) {
        if (span->note[i] != SILENCE) {
            result += 1;
        }
    }
    return result;
}

audioio_get_buffer_result_t synthio_miditrack_get_buffer(synthio_miditrack_obj_t *self,
    bool single_channel_output, uint8_t channel, uint8_t **buffer, uint32_t *buffer_length) {
    synthio_midi_span_t span = self->track[self->next_span - !!self->remaining_dur];

    if (self->remaining_dur == 0) {
        if (self->next_span >= self->total_spans) {
            *buffer_length = 0;
            return GET_BUFFER_DONE;
        }
        self->next_span++;
        self->remaining_dur = span.dur;
    }

    uint16_t dur = MIN(MAX_DUR, self->remaining_dur);
    self->remaining_dur -= dur;
    *buffer_length = dur * BYTES_PER_SAMPLE;
    memset(self->buffer, 0, *buffer_length);

    int32_t sample_rate = self->sample_rate;
    int active_channels = count_active_channels(&span);
    const int16_t *waveform = self->waveform;
    uint32_t waveform_length = self->waveform_length;
    int16_t *out_buffer = self->buffer;
    if (active_channels) {
        int16_t loudness = 0x3fff / (1 + active_channels);
        for (int chan = 0; chan < CIRCUITPY_SYNTHIO_MAX_CHANNELS; chan++) {
            if (span.note[chan] == SILENCE) {
                self->accum[chan] = 0;
                continue;
            }
            uint8_t octave = span.note[chan] / 12;
            uint16_t base_freq = notes[span.note[chan] % 12];
            uint32_t accum = self->accum[chan];
#define SHIFT (16)
            // rate = base_freq * waveform_length
            // den = sample_rate * 2 ^ (10 - octave)
            // den = sample_rate * 2 ^ 10 / 2^octave
            // dds_rate = 2^SHIFT * rate / den
            // dds_rate = 2^(SHIFT-10+octave) * base_freq * waveform_length / sample_rate
            uint32_t dds_rate = (sample_rate / 2 + ((uint64_t)(base_freq * waveform_length) << (SHIFT - 10 + octave))) / sample_rate;

            for (uint16_t i = 0; i < dur; i++) {
                accum += dds_rate;
                if (accum > waveform_length << SHIFT) {
                    accum -= waveform_length << SHIFT;
                }
                int16_t idx = accum >> SHIFT;
                out_buffer[i] += (waveform[idx] * loudness) / 65536;
            }
            self->accum[chan] = accum;
        }
    }

    *buffer = (uint8_t *)self->buffer;

    return (self->remaining_dur == 0 && self->next_span >= self->total_spans) ?
           GET_BUFFER_DONE : GET_BUFFER_MORE_DATA;
}

void synthio_miditrack_get_buffer_structure(synthio_miditrack_obj_t *self, bool single_channel_output,
    bool *single_buffer, bool *samples_signed, uint32_t *max_buffer_length, uint8_t *spacing) {

    *single_buffer = true;
    *samples_signed = true;
    *max_buffer_length = self->buffer_length;
    *spacing = 1;
}