#pragma once

#include "AudioVoiceEngine.hpp"
#include "logvisor/logvisor.hpp"
#include <thread>

#include <alsa/asoundlib.h>
#include <signal.h>

namespace boo {
extern logvisor::Module ALSALog;

static inline double TimespecToDouble(struct timespec& ts) { return ts.tv_sec + ts.tv_nsec / 1.0e9; }

struct LinuxMidi : BaseAudioVoiceEngine {
  std::unordered_map<std::string, IMIDIPort*> m_openHandles;
  void _addOpenHandle(const char* name, IMIDIPort* port) { m_openHandles[name] = port; }
  void _removeOpenHandle(IMIDIPort* port) {
    for (auto it = m_openHandles.begin(); it != m_openHandles.end();) {
      if (it->second == port) {
        it = m_openHandles.erase(it);
        continue;
      }
      ++it;
    }
  }

  ~LinuxMidi() {
    for (auto& p : m_openHandles)
      p.second->_disown();
  }

  std::vector<std::pair<std::string, std::string>> enumerateMIDIInputs() const {
    std::vector<std::pair<std::string, std::string>> ret;
    int status;
    int card = -1; /* use -1 to prime the pump of iterating through card list */

    if ((status = snd_card_next(&card)) < 0)
      return {};
    if (card < 0)
      return {};

    snd_rawmidi_info_t* info;
    snd_rawmidi_info_malloc(&info);

    while (card >= 0) {
      snd_ctl_t* ctl;
      char name[32];
      int device = -1;
      int status;
      sprintf(name, "hw:%d", card);
      if ((status = snd_ctl_open(&ctl, name, 0)) < 0)
        continue;

      do {
        status = snd_ctl_rawmidi_next_device(ctl, &device);
        if (status < 0)
          break;
        if (device >= 0) {
          sprintf(name + strlen(name), ",%d", device);
          auto search = m_openHandles.find(name);
          if (search != m_openHandles.cend()) {
            ret.push_back(std::make_pair(name, search->second->description()));
            continue;
          }

          snd_rawmidi_t* midi;
          if (!snd_rawmidi_open(&midi, nullptr, name, SND_RAWMIDI_NONBLOCK)) {
            snd_rawmidi_info(midi, info);
            ret.push_back(std::make_pair(name, snd_rawmidi_info_get_name(info)));
            snd_rawmidi_close(midi);
          }
        }
      } while (device >= 0);

      snd_ctl_close(ctl);

      if ((status = snd_card_next(&card)) < 0)
        break;
    }

    snd_rawmidi_info_free(info);

    return ret;
  }

  bool supportsVirtualMIDIIn() const { return true; }

  static void MIDIFreeProc(void* midiStatus) { snd_rawmidi_status_free((snd_rawmidi_status_t*)midiStatus); }

  static void MIDIReceiveProc(snd_rawmidi_t* midi, const ReceiveFunctor& receiver) {
    logvisor::RegisterThreadName("Boo MIDI");
    snd_rawmidi_status_t* midiStatus;
    snd_rawmidi_status_malloc(&midiStatus);
    pthread_cleanup_push(MIDIFreeProc, midiStatus);

    uint8_t buf[512];
    while (true) {
      snd_htimestamp_t ts;
      snd_rawmidi_status(midi, midiStatus);
      snd_rawmidi_status_get_tstamp(midiStatus, &ts);
      int rdBytes = snd_rawmidi_read(midi, buf, 512);
      if (rdBytes < 0) {
        if (rdBytes != -EINTR) {
          ALSALog.report(logvisor::Error, "MIDI connection lost");
          break;
        }
        continue;
      }

      int oldtype;
      pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldtype);
      receiver(std::vector<uint8_t>(std::cbegin(buf), std::cbegin(buf) + rdBytes), TimespecToDouble(ts));
      pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldtype);
      pthread_testcancel();
    }

    pthread_cleanup_pop(1);
  }

  struct MIDIIn : public IMIDIIn {
    snd_rawmidi_t* m_midi;
    std::thread m_midiThread;

    MIDIIn(LinuxMidi* parent, snd_rawmidi_t* midi, bool virt, ReceiveFunctor&& receiver)
    : IMIDIIn(parent, virt, std::move(receiver))
    , m_midi(midi)
    , m_midiThread(std::bind(MIDIReceiveProc, m_midi, m_receiver)) {}

    ~MIDIIn() {
      if (m_parent)
        static_cast<LinuxMidi*>(m_parent)->_removeOpenHandle(this);
      pthread_cancel(m_midiThread.native_handle());
      if (m_midiThread.joinable())
        m_midiThread.join();
      snd_rawmidi_close(m_midi);
    }

    std::string description() const {
      snd_rawmidi_info_t* info;
      snd_rawmidi_info_alloca(&info);
      snd_rawmidi_info(m_midi, info);
      std::string ret = snd_rawmidi_info_get_name(info);
      return ret;
    }
  };

  struct MIDIOut : public IMIDIOut {
    snd_rawmidi_t* m_midi;
    MIDIOut(LinuxMidi* parent, snd_rawmidi_t* midi, bool virt) : IMIDIOut(parent, virt), m_midi(midi) {}

    ~MIDIOut() {
      if (m_parent)
        static_cast<LinuxMidi*>(m_parent)->_removeOpenHandle(this);
      snd_rawmidi_close(m_midi);
    }

    std::string description() const {
      snd_rawmidi_info_t* info;
      snd_rawmidi_info_alloca(&info);
      snd_rawmidi_info(m_midi, info);
      std::string ret = snd_rawmidi_info_get_name(info);
      return ret;
    }

    size_t send(const void* buf, size_t len) const { return size_t(std::max(0l, snd_rawmidi_write(m_midi, buf, len))); }
  };

  struct MIDIInOut : public IMIDIInOut {
    snd_rawmidi_t* m_midiIn;
    snd_rawmidi_t* m_midiOut;
    std::thread m_midiThread;

    MIDIInOut(LinuxMidi* parent, snd_rawmidi_t* midiIn, snd_rawmidi_t* midiOut, bool virt, ReceiveFunctor&& receiver)
    : IMIDIInOut(parent, virt, std::move(receiver))
    , m_midiIn(midiIn)
    , m_midiOut(midiOut)
    , m_midiThread(std::bind(MIDIReceiveProc, m_midiIn, m_receiver)) {}

    ~MIDIInOut() {
      if (m_parent)
        static_cast<LinuxMidi*>(m_parent)->_removeOpenHandle(this);
      pthread_cancel(m_midiThread.native_handle());
      if (m_midiThread.joinable())
        m_midiThread.join();
      snd_rawmidi_close(m_midiIn);
      snd_rawmidi_close(m_midiOut);
    }

    std::string description() const {
      snd_rawmidi_info_t* info;
      snd_rawmidi_info_alloca(&info);
      snd_rawmidi_info(m_midiIn, info);
      std::string ret = snd_rawmidi_info_get_name(info);
      return ret;
    }

    size_t send(const void* buf, size_t len) const {
      return size_t(std::max(0l, snd_rawmidi_write(m_midiOut, buf, len)));
    }
  };

  std::unique_ptr<IMIDIIn> newVirtualMIDIIn(ReceiveFunctor&& receiver) {
    int status;
    snd_rawmidi_t* midi;
    status = snd_rawmidi_open(&midi, nullptr, "virtual", 0);
    if (status)
      return {};
    return std::make_unique<MIDIIn>(nullptr, midi, true, std::move(receiver));
  }

  std::unique_ptr<IMIDIOut> newVirtualMIDIOut() {
    int status;
    snd_rawmidi_t* midi;
    status = snd_rawmidi_open(nullptr, &midi, "virtual", 0);
    if (status)
      return {};
    return std::make_unique<MIDIOut>(nullptr, midi, true);
  }

  std::unique_ptr<IMIDIInOut> newVirtualMIDIInOut(ReceiveFunctor&& receiver) {
    int status;
    snd_rawmidi_t* midiIn;
    snd_rawmidi_t* midiOut;
    status = snd_rawmidi_open(&midiIn, &midiOut, "virtual", 0);
    if (status)
      return {};
    return std::make_unique<MIDIInOut>(nullptr, midiIn, midiOut, true, std::move(receiver));
  }

  std::unique_ptr<IMIDIIn> newRealMIDIIn(const char* name, ReceiveFunctor&& receiver) {
    snd_rawmidi_t* midi;
    int status = snd_rawmidi_open(&midi, nullptr, name, 0);
    if (status)
      return {};
    auto ret = std::make_unique<MIDIIn>(this, midi, true, std::move(receiver));
    _addOpenHandle(name, ret.get());
    return ret;
  }

  std::unique_ptr<IMIDIOut> newRealMIDIOut(const char* name) {
    snd_rawmidi_t* midi;
    int status = snd_rawmidi_open(nullptr, &midi, name, 0);
    if (status)
      return {};
    auto ret = std::make_unique<MIDIOut>(this, midi, true);
    _addOpenHandle(name, ret.get());
    return ret;
  }

  std::unique_ptr<IMIDIInOut> newRealMIDIInOut(const char* name, ReceiveFunctor&& receiver) {
    snd_rawmidi_t* midiIn;
    snd_rawmidi_t* midiOut;
    int status = snd_rawmidi_open(&midiIn, &midiOut, name, 0);
    if (status)
      return {};
    auto ret = std::make_unique<MIDIInOut>(this, midiIn, midiOut, true, std::move(receiver));
    _addOpenHandle(name, ret.get());
    return ret;
  }

  bool useMIDILock() const { return true; }
};

} // namespace boo