#include "MidiMessageSequence.h"

#include "Pattern/MidiPattern.h"
#include "Singleton/PortAudioAPI.h"
#include "Thread/MainThreadEventList.h"
#include "Math.h"
#include "Thread/ThreadMessage.h"

DECLARE_THREAD_MESSAGE(FMainThreadEventList, OnMidiPatternChanged,
    FMidiPattern* Pattern;
    FMidiMessageSequence* MidiMessageSequence;
)
{
    Args.Pattern->NotifyOnChanged_MainThread(Args.MidiMessageSequence);
}

DECLARE_THREAD_MESSAGE(FPortAudioAPI, SortMidiMessageSequence,
    FMidiMessageSequence* MidiMessageSequence;
    FMidiPattern* Pattern;
)
{
    Args.MidiMessageSequence->sort();
    Args.MidiMessageSequence->updateMatchedPairs();
    Args.Pattern->NotifyOnChanged(Args.MidiMessageSequence);
    PUSH_THREAD_EVENT(OnMidiPatternChanged, Args.Pattern, Args.MidiMessageSequence);
}

FMidiMessageSequence::MidiEventHolder::MidiEventHolder (const FMidiMessage& mm) : message (mm) {}
FMidiMessageSequence::MidiEventHolder::MidiEventHolder (FMidiMessage&& mm) : message (std::move (mm)) {}

//==============================================================================
FMidiMessageSequence::FMidiMessageSequence()
{
}

FMidiMessageSequence::FMidiMessageSequence (const FMidiMessageSequence& other)
{
    list.Append(other.list);

    for (int i = 0; i < list.Num(); ++i)
    {
        auto noteOffIndex = other.getIndexOfMatchingKeyUp (i);

        if (noteOffIndex >= 0)
            list.GetData()[i]->noteOffObject = list.GetData()[noteOffIndex];
    }
}

FMidiMessageSequence& FMidiMessageSequence::operator= (const FMidiMessageSequence& other)
{
    FMidiMessageSequence otherCopy (other);
    swapWith (otherCopy);
    return *this;
}

FMidiMessageSequence::FMidiMessageSequence (FMidiMessageSequence&& other) noexcept
    : list (std::move (other.list))
{
}

FMidiMessageSequence& FMidiMessageSequence::operator= (FMidiMessageSequence&& other) noexcept
{
    list = std::move (other.list);
    return *this;
}

void FMidiMessageSequence::swapWith (FMidiMessageSequence& other) noexcept
{
    Swap(list, other.list);
}

TRange<int32> FMidiMessageSequence::GetNoteRange() const
{
    int32 MinNote = 127;
    int32 MaxNote = 0;
    for (const auto& MidiEventHolder : list)
    {
        const FMidiMessage& MidiMessage = MidiEventHolder->message;
        if (MidiMessage.isNoteOn())
        {
            const int32 Note = MidiMessage.getNoteNumber();
            MinNote = FMath::Min(MinNote, Note);
            MaxNote = FMath::Max(MaxNote, Note);
        }
    }
    return TRange<int32>(MinNote, MaxNote);
}

void FMidiMessageSequence::clear()
{
    list.Empty();
}

int FMidiMessageSequence::getNumEvents() const noexcept
{
    return list.Num();
}

FMidiMessageSequence::MidiEventHolder* FMidiMessageSequence::getEventPointer (int index) const noexcept
{
    return list[index];
}

FMidiMessageSequence::MidiEventHolder** FMidiMessageSequence::begin() noexcept               { return list.GetData(); }
FMidiMessageSequence::MidiEventHolder* const* FMidiMessageSequence::begin() const noexcept   { return list.GetData(); }
FMidiMessageSequence::MidiEventHolder** FMidiMessageSequence::end() noexcept                 { return list.GetData() + list.Num(); }
FMidiMessageSequence::MidiEventHolder* const* FMidiMessageSequence::end() const noexcept     { return list.GetData() + list.Num(); }

double FMidiMessageSequence::getTimeOfMatchingKeyUp (int index) const noexcept
{
    if (!list.IsValidIndex(index))
        return 0;
    auto* meh = list[index];
    if (auto* noteOff = meh->noteOffObject)
        return noteOff->message.getTimeStamp();

    return 0;
}

int FMidiMessageSequence::getIndexOfMatchingKeyUp (int index) const noexcept
{
    if (!list.IsValidIndex(index))
        return -1;
    
    auto* meh = list[index];
    
    if (auto* noteOff = meh->noteOffObject)
    {
        for (int i = index; i < list.Num(); ++i)
            if (list.GetData()[i] == noteOff)
                return i;

        check(0); // we've somehow got a pointer to a note-off object that isn't in the sequence
    }
    

    return -1;
}

int FMidiMessageSequence::getIndexOf (const MidiEventHolder* event) const noexcept
{
    return list.Find(const_cast<MidiEventHolder*>(event));
}

int FMidiMessageSequence::getNextIndexAtTime (double timeStamp) const noexcept
{
    auto numEvents = list.Num();
    int i;

    for (i = 0; i < numEvents; ++i)
        if (list.GetData()[i]->message.getTimeStamp() >= timeStamp)
            break;

    return i;
}

//==============================================================================
double FMidiMessageSequence::getStartTime() const noexcept
{
    return getEventTime (0);
}

double FMidiMessageSequence::getEndTime() const noexcept
{
    return getEventTime (list.Num() - 1);
}

double FMidiMessageSequence::getEventTime (const int index) const noexcept
{
    if (list.IsValidIndex(index))
        return list[index]->message.getTimeStamp();

    return 0;
}

//==============================================================================
FMidiMessageSequence::MidiEventHolder* FMidiMessageSequence::addEvent (MidiEventHolder* newEvent, double timeAdjustment)
{
    newEvent->message.addToTimeStamp (timeAdjustment);
    auto time = newEvent->message.getTimeStamp();
    int i;

    for (i = list.Num(); --i >= 0;)
        if (list.GetData()[i]->message.getTimeStamp() <= time)
            break;

    list.Insert(newEvent, i + 1);
    return newEvent;
}

FMidiMessageSequence::MidiEventHolder* FMidiMessageSequence::addEvent (const FMidiMessage& newMessage, double timeAdjustment)
{
    return addEvent (new MidiEventHolder (newMessage), timeAdjustment);
}

FMidiMessageSequence::MidiEventHolder* FMidiMessageSequence::addEvent (FMidiMessage&& newMessage, double timeAdjustment)
{
    return addEvent (new MidiEventHolder (std::move (newMessage)), timeAdjustment);
}

void FMidiMessageSequence::deleteEvent (int index, bool deleteMatchingNoteUp)
{
    if (IsPositiveAndBelow(index, list.Num()))
    {
        if (deleteMatchingNoteUp)
            deleteEvent (getIndexOfMatchingKeyUp (index), false);

        list.RemoveAt(index);
    }
}

void FMidiMessageSequence::addSequence (const FMidiMessageSequence& other, double timeAdjustment)
{
    for (auto* m : other)
    {
        auto newOne = new MidiEventHolder (m->message);
        newOne->message.addToTimeStamp (timeAdjustment);
        list.Add(newOne);
    }

    sort();
}

void FMidiMessageSequence::addSequence (const FMidiMessageSequence& other,
                                       double timeAdjustment,
                                       double firstAllowableTime,
                                       double endOfAllowableDestTimes)
{
    for (auto* m : other)
    {
        auto t = m->message.getTimeStamp() + timeAdjustment;

        if (t >= firstAllowableTime && t < endOfAllowableDestTimes)
        {
            auto newOne = new MidiEventHolder (m->message);
            newOne->message.setTimeStamp (t);
            list.Add(newOne);
        }
    }

    sort();
}

void FMidiMessageSequence::sort() noexcept
{
    Algo::StableSort(list, [](const MidiEventHolder* a, const MidiEventHolder* b)
    {
        return a->message.getTimeStamp() < b->message.getTimeStamp();
    });
}

void FMidiMessageSequence::sortAudioThread()
{
    PUSH_THREAD_EVENT(SortMidiMessageSequence, this, pattern);
}

void FMidiMessageSequence::updateMatchedPairs() noexcept
{
    for (int i = 0; i < list.Num(); ++i)
    {
        auto* meh = list.GetData()[i];
        auto& m1 = meh->message;

        if (m1.isNoteOn())
        {
            meh->noteOffObject = nullptr;
            auto note = m1.getNoteNumber();
            auto chan = m1.getChannel();
            auto len = list.Num();

            for (int j = i + 1; j < len; ++j)
            {
                auto* meh2 = list.GetData()[j];
                auto& m = meh2->message;

                if (m.getNoteNumber() == note && m.getChannel() == chan)
                {
                    if (m.isNoteOff())
                    {
                        meh->noteOffObject = meh2;
                        break;
                    }

                    if (m.isNoteOn())
                    {
                        auto newEvent = new MidiEventHolder(FMidiMessage::noteOff(chan, note));
                        list.Insert(newEvent, j);
                        newEvent->message.setTimeStamp (m.getTimeStamp());
                        meh->noteOffObject = newEvent;
                        break;
                    }
                }
            }
        }
    }
}

void FMidiMessageSequence::addTimeToMessages (double delta) noexcept
{
    if (delta != 0)
        for (auto* m : list)
            m->message.addToTimeStamp (delta);
}

//==============================================================================
void FMidiMessageSequence::extractMidiChannelMessages (const int channelNumberToExtract,
                                                      FMidiMessageSequence& destSequence,
                                                      const bool alsoIncludeMetaEvents) const
{
    for (auto* meh : list)
        if (meh->message.isForChannel (channelNumberToExtract)
             || (alsoIncludeMetaEvents && meh->message.isMetaEvent()))
            destSequence.addEvent (meh->message);
}

void FMidiMessageSequence::extractSysExMessages (FMidiMessageSequence& destSequence) const
{
    for (auto* meh : list)
        if (meh->message.isSysEx())
            destSequence.addEvent (meh->message);
}

void FMidiMessageSequence::deleteMidiChannelMessages (const int channelNumberToRemove)
{
    for (int i = list.Num(); --i >= 0;)
        if (list.GetData()[i]->message.isForChannel (channelNumberToRemove))
            list.RemoveAt(i);
}

void FMidiMessageSequence::deleteSysExMessages()
{
    for (int i = list.Num(); --i >= 0;)
        if (list.GetData()[i]->message.isSysEx())
            list.RemoveAt(i);
}

//==============================================================================
class OptionalPitchWheel
{
    TOptional<int> value;

public:
    void emit (int channel, TArray<FMidiMessage>& out) const
    {
        if (value.IsSet())
            out.Add(FMidiMessage::pitchWheel (channel, *value));
    }

    void set (int v)
    {
        value = v;
    }
};

class OptionalControllerValues
{
    TOptional<char> values[128];

public:
    void emit (int channel, TArray<FMidiMessage>& out) const
    {
        for (auto it = std::begin (values); it != std::end (values); ++it)
            if (it->IsSet())
                out.Add(FMidiMessage::controllerEvent (channel, (int) std::distance (std::begin (values), it), **it));
    }

    void set (int controller, int value)
    {
        values[controller] = (char) value;
    }
};

class OptionalProgramChange
{
    TOptional<char> value, bankLSB, bankMSB;

public:
    void emit (int channel, double time, TArray<FMidiMessage>& out) const
    {
        if (! value.IsSet())
            return;

        if (bankLSB.IsSet() && bankMSB.IsSet())
        {
            out.Add(FMidiMessage::controllerEvent (channel, 0x00, *bankMSB).withTimeStamp (time));
            out.Add(FMidiMessage::controllerEvent (channel, 0x20, *bankLSB).withTimeStamp (time));
        }

        out.Add(FMidiMessage::programChange (channel, *value).withTimeStamp (time));
    }

    // Returns true if this is a bank number change, and false otherwise.
    bool trySetBank (int controller, int v)
    {
        switch (controller)
        {
            case 0x00: bankMSB = (char) v; return true;
            case 0x20: bankLSB = (char) v; return true;
        }

        return false;
    }

    void setProgram (int v) { value = (char) v; }
};

class ParameterNumberState
{
    enum class Kind { rpn, nrpn };

    TOptional<char> newestRpnLsb, newestRpnMsb, newestNrpnLsb, newestNrpnMsb, lastSentLsb, lastSentMsb;
    Kind lastSentKind = Kind::rpn, newestKind = Kind::rpn;

public:
    // If the effective parameter number has changed since the last time this function was called,
    // this will emit the current parameter in full (MSB and LSB).
    // This should be called before each data message (entry, increment, decrement: 0x06, 0x26, 0x60, 0x61)
    // to ensure that the data message operates on the correct parameter number.
    void sendIfNecessary (int channel, double time, TArray<FMidiMessage>& out)
    {
        const auto newestMsb = newestKind == Kind::rpn ? newestRpnMsb : newestNrpnMsb;
        const auto newestLsb = newestKind == Kind::rpn ? newestRpnLsb : newestNrpnLsb;

        auto lastSent = std::tie (lastSentKind, lastSentMsb, lastSentLsb);
        const auto newest = std::tie (newestKind, newestMsb, newestLsb);

        if (lastSent == newest || ! newestMsb.IsSet() || ! newestLsb.IsSet())
            return;

        out.Add(FMidiMessage::controllerEvent (channel, newestKind == Kind::rpn ? 0x65 : 0x63, *newestMsb).withTimeStamp (time));
        out.Add(FMidiMessage::controllerEvent (channel, newestKind == Kind::rpn ? 0x64 : 0x62, *newestLsb).withTimeStamp (time));

        lastSent = newest;
    }

    // Returns true if this is a parameter number change, and false otherwise.
    bool trySetProgramNumber (int controller, int value)
    {
        switch (controller)
        {
            case 0x65: newestRpnMsb  = (char) value; newestKind = Kind::rpn;  return true;
            case 0x64: newestRpnLsb  = (char) value; newestKind = Kind::rpn;  return true;
            case 0x63: newestNrpnMsb = (char) value; newestKind = Kind::nrpn; return true;
            case 0x62: newestNrpnLsb = (char) value; newestKind = Kind::nrpn; return true;
        }

        return false;
    }
};

void FMidiMessageSequence::createControllerUpdatesForTime(int channel, double time, TArray<FMidiMessage>& dest)
{
    OptionalProgramChange programChange;
    OptionalControllerValues controllers;
    OptionalPitchWheel pitchWheel;
    ParameterNumberState parameterNumberState;

    for (const auto& item : list)
    {
        const auto& mm = item->message;

        if (! (mm.isForChannel (channel) && mm.getTimeStamp() <= time))
            continue;

        if (mm.isController())
        {
            const auto num = mm.getControllerNumber();

            if (parameterNumberState.trySetProgramNumber (num, mm.getControllerValue()))
                continue;

            if (programChange.trySetBank (num, mm.getControllerValue()))
                continue;

            constexpr int passthroughs[] { 0x06, 0x26, 0x60, 0x61 };

            if (std::find (std::begin (passthroughs), std::end (passthroughs), num) != std::end (passthroughs))
            {
                parameterNumberState.sendIfNecessary (channel, mm.getTimeStamp(), dest);
                dest.Add(mm);
            }
            else
            {
                controllers.set (num, mm.getControllerValue());
            }
        }
        else if (mm.isProgramChange())
        {
            programChange.setProgram (mm.getProgramChangeNumber());
        }
        else if (mm.isPitchWheel())
        {
            pitchWheel.set (mm.getPitchWheelValue());
        }
    }

    pitchWheel.emit (channel, dest);
    controllers.emit (channel, dest);

    // Also emits bank change messages if necessary.
    programChange.emit (channel, time, dest);

    // Set the parameter number to its final state.
    parameterNumberState.sendIfNecessary (channel, time, dest);
}