/**
 * Copyright (c) 2021 Enzien Audio, Ltd.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions, and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the phrase "powered by heavy",
 *    the heavy logo, and a hyperlink to https://enzienaudio.com, all in a visible
 *    form.
 * 
 *   2.1 If the Application is distributed in a store system (for example,
 *       the Apple "App Store" or "Google Play"), the phrase "powered by heavy"
 *       shall be included in the app description or the copyright text as well as
 *       the in the app itself. The heavy logo will shall be visible in the app
 *       itself as well.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */

#include "HeavyDPF_dpf_midi_thru.hpp"


#define HV_LV2_NUM_PARAMETERS 0

#define HV_HASH_NOTEIN    0x67e37ca3
#define HV_HASH_CTLIN     0x41be0f9c
#define HV_HASH_PGMIN     0x2e1ea03d
#define HV_HASH_TOUCHIN   0x553925bd
#define HV_HASH_BENDIN    0x3083f0f7
#define HV_HASH_MIDIIN    0x149631be

#define HV_HASH_NOTEOUT   0xd1d4ac2
#define HV_HASH_CTLOUT    0xe5e2a040
#define HV_HASH_PGMOUT    0x8753e39e
#define HV_HASH_TOUCHOUT  0x476d4387
#define HV_HASH_BENDOUT   0xe8458013
#define HV_HASH_MIDIOUT   0x6511de55


START_NAMESPACE_DISTRHO

static void hvSendHookFunc(HeavyContextInterface *c, const char *sendName, uint32_t sendHash, const HvMessage *m)
{
  HeavyDPF_dpf_midi_thru* plugin = (HeavyDPF_dpf_midi_thru*)c->getUserData();
  if (plugin != nullptr)
  {
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
    plugin->handleMidiSend(sendHash, m);
#endif
  }
}

static void hvPrintHookFunc(HeavyContextInterface *c, const char *printLabel, const char *msgString, const HvMessage *m)
{
  char buf[64];
  char* dst = buf;
  int len = strnlen(printLabel, 48);
  dst = stpncpy(dst, printLabel, len);
  dst = stpcpy(dst, " ");
  dst = stpncpy(dst, msgString, 63-len);
  printf("> %s \n", buf);
}

HeavyDPF_dpf_midi_thru::HeavyDPF_dpf_midi_thru()
 : Plugin(HV_LV2_NUM_PARAMETERS, 0, 0)
{
  

  _context = new Heavy_dpf_midi_thru(getSampleRate(), 10, 2, 5);
  _context->setUserData(this);
  _context->setSendHook(&hvSendHookFunc);
  _context->setPrintHook(&hvPrintHookFunc);

  
}

HeavyDPF_dpf_midi_thru::~HeavyDPF_dpf_midi_thru() {
  delete _context;
}

void HeavyDPF_dpf_midi_thru::initParameter(uint32_t index, Parameter& parameter)
{
  
}

// -------------------------------------------------------------------
// Internal data

float HeavyDPF_dpf_midi_thru::getParameterValue(uint32_t index) const
{
  
  return 0.0f;
  
}

void HeavyDPF_dpf_midi_thru::setParameterValue(uint32_t index, float value)
{
  
  // nothing to do
  
}


// -------------------------------------------------------------------
// Process

// void HeavyDPF_dpf_midi_thru::activate()
// {

// }

// void HeavyDPF_dpf_midi_thru::deactivate()
// {

// }

#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
void HeavyDPF_dpf_midi_thru::handleMidiInput(uint32_t curEventIndex, const MidiEvent* midiEvents)
{
  int status = midiEvents[curEventIndex].data[0];
  int command = status & 0xF0;
  int channel = status & 0x0F;
  int data1   = midiEvents[curEventIndex].data[1];
  int data2   = midiEvents[curEventIndex].data[2];

  // raw [midiin] messages
  _context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
    (float) status,
    (float) channel);

  _context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
    (float) data1,
    (float) channel);

  _context->sendMessageToReceiverV(HV_HASH_MIDIIN, 0, "ff",
    (float) data2,
    (float) channel);

  switch (command) {
    case 0x80: {  // note off
      _context->sendMessageToReceiverV(HV_HASH_NOTEIN, 0, "fff",
        (float) data1, // pitch
        (float) 0, // velocity
        (float) channel);
      break;
    }
    case 0x90: { // note on
      _context->sendMessageToReceiverV(HV_HASH_NOTEIN, 0, "fff",
        (float) data1, // pitch
        (float) data2, // velocity
        (float) channel);
      break;
    }
    case 0xB0: { // control change
      _context->sendMessageToReceiverV(HV_HASH_CTLIN, 0, "fff",
        (float) data2, // value
        (float) data1, // cc number
        (float) channel);
      break;
    }
    case 0xC0: { // program change
      _context->sendMessageToReceiverV(HV_HASH_PGMIN, 0, "ff",
        (float) data1,
        (float) channel);
      break;
    }
    case 0xD0: { // aftertouch
      _context->sendMessageToReceiverV(HV_HASH_TOUCHIN, 0, "ff",
        (float) data1,
        (float) channel);
      break;
    }
    case 0xE0: { // pitch bend
      // combine 7bit lsb and msb into 32bit int
      hv_uint32_t value = (((hv_uint32_t) data2) << 7) | ((hv_uint32_t) data1);
      _context->sendMessageToReceiverV(HV_HASH_BENDIN, 0, "ff",
        (float) value,
        (float) channel);
      break;
    }
    default: break;
  }
}
#endif

#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
void HeavyDPF_dpf_midi_thru::handleMidiSend(uint32_t sendHash, const HvMessage *m)
{
  MidiEvent midiSendEvent;
  midiSendEvent.frame = 0;
  midiSendEvent.dataExt = nullptr;

  switch(sendHash){
    case HV_HASH_NOTEOUT: // __hv_noteout
    {
      uint8_t note = hv_msg_getFloat(m, 0);
      uint8_t velocity = hv_msg_getFloat(m, 1);
      uint8_t ch = hv_msg_getFloat(m, 2);

      midiSendEvent.size = 3;
      if (velocity > 0){
        midiSendEvent.data[0] = 0x90 | ch; // noteon
      } else {
        midiSendEvent.data[0] = 0x80 | ch; // noteoff
      }
      midiSendEvent.data[1] = note;
      midiSendEvent.data[2] = velocity;

      writeMidiEvent(midiSendEvent);
      break;
    }
    case HV_HASH_CTLOUT:
    {
      uint8_t value = hv_msg_getFloat(m, 0);
      uint8_t cc = hv_msg_getFloat(m, 1);
      uint8_t ch = hv_msg_getFloat(m, 2);

      midiSendEvent.size = 3;
      midiSendEvent.data[0] = 0xB0 | ch; // send CC
      midiSendEvent.data[1] = cc;
      midiSendEvent.data[2] = value;

      writeMidiEvent(midiSendEvent);
      break;
    }
    case HV_HASH_PGMOUT:
    {
      uint8_t pgm = hv_msg_getFloat(m, 0);
      uint8_t ch = hv_msg_getFloat(m, 1);

      midiSendEvent.size = 2;
      midiSendEvent.data[0] = 0xC0 | ch; // send Program Change
      midiSendEvent.data[1] = pgm;

      writeMidiEvent(midiSendEvent);
      break;
    }
    case HV_HASH_TOUCHOUT:
    {
      uint8_t value = hv_msg_getFloat(m, 0);
      uint8_t ch = hv_msg_getFloat(m, 1);

      midiSendEvent.size = 2;
      midiSendEvent.data[0] = 0xD0 | ch; // send Touch
      midiSendEvent.data[1] = value;

      writeMidiEvent(midiSendEvent);
      break;
    }
    case HV_HASH_BENDOUT:
    {
      uint16_t value = hv_msg_getFloat(m, 0);
      uint8_t lsb  = value & 0x7F;
      uint8_t msb  = (value >> 7) & 0x7F;
      uint8_t ch = hv_msg_getFloat(m, 1);

      midiSendEvent.size = 3;
      midiSendEvent.data[0] = 0xE0 | ch; // send Bend
      midiSendEvent.data[1] = lsb;
      midiSendEvent.data[2] = msb;

      writeMidiEvent(midiSendEvent);
      break;
    }
    // case HV_HASH_MIDIOUT: // __hv_midiout
    // {
    //   midiSendEvent.size = m->numElements;
    //   // midiSendEvent.dataExt = (const uint8_t *) m->elem->data;

    //   const char* rawdata = new const char[m->numElements];

    //   for (int i = 0; i < m->numElements; ++i) {
    //     rawdata[i] = hv_msg_getFloat(m, i);
    //   }
    //   midiSendEvent.dataExt = (const uint8_t *) rawdata;

    //   writeMidiEvent(midiSendEvent);
    // }
    default:
      break;
  }
}
#endif

#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
void HeavyDPF_dpf_midi_thru::run(const float** inputs, float** outputs, uint32_t frames, const MidiEvent* midiEvents, uint32_t midiEventCount)
{
  for (uint32_t i=0; i < midiEventCount; ++i)
  {
    handleMidiInput(i, midiEvents);
  }
#else
void HeavyDPF_dpf_midi_thru::run(const float** inputs, float** outputs, uint32_t frames)
{
#endif

  _context->process((float**)inputs, outputs, frames);
}

// -------------------------------------------------------------------
// Callbacks

void HeavyDPF_dpf_midi_thru::sampleRateChanged(double newSampleRate)
{
  delete _context;

  _context = new Heavy_dpf_midi_thru(newSampleRate, 10, 2, 5);
  _context->setUserData(this);
  _context->setSendHook(&hvSendHookFunc);
  _context->setPrintHook(&hvPrintHookFunc);

  
}


// -----------------------------------------------------------------------
/* Plugin entry point, called by DPF to create a new plugin instance. */

Plugin* createPlugin()
{
    return new HeavyDPF_dpf_midi_thru();
}

// -----------------------------------------------------------------------

END_NAMESPACE_DISTRHO