/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "TestMIDIPlatformService.h"

#include "mozilla/dom/MIDIPort.h"

#include "mozilla/dom/MIDITypes.h"

#include "mozilla/dom/MIDIPortInterface.h"

#include "mozilla/dom/MIDIPortParent.h"

#include "mozilla/dom/MIDIPlatformRunnables.h"

#include "mozilla/dom/MIDIUtils.h"

#include "mozilla/ipc/BackgroundParent.h"

#include "mozilla/Unused.h"

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::ipc;

/**

 * Runnable used for making sure ProcessMessages only happens on the IO thread.

 *

 */

class ProcessMessagesRunnable : public mozilla::Runnable

{

public:

  explicit ProcessMessagesRunnable(const nsAString& aPortID) :

    Runnable("ProcessMessagesRunnable"),

    mPortID(aPortID)

  {}

  ~ProcessMessagesRunnable() {}

  NS_IMETHOD Run()

  {

    // If service is no longer running, just exist without processing.

    if (!MIDIPlatformService::IsRunning()) {

      return NS_OK;

    }

    TestMIDIPlatformService* srv = static_cast<TestMIDIPlatformService*>(MIDIPlatformService::Get());

    srv->ProcessMessages(mPortID);

    return NS_OK;

  }

private:

  nsString mPortID;

};

/**

 * Runnable used for allowing IO thread to queue more messages for processing,

 * since it can't access the service object directly.

 *

 */

class QueueMessagesRunnable : public MIDIBackgroundRunnable

{

public:

  QueueMessagesRunnable(const nsAString& aPortID,

                        const nsTArray<MIDIMessage>& aMsgs) :

    MIDIBackgroundRunnable("QueueMessagesRunnable"),

    mPortID(aPortID),

    mMsgs(aMsgs)

  {}

  ~QueueMessagesRunnable() {}

  virtual void RunInternal()

  {

    AssertIsOnBackgroundThread();

    MIDIPlatformService::Get()->QueueMessages(mPortID, mMsgs);

  }

private:

  nsString mPortID;

  nsTArray<MIDIMessage> mMsgs;

};

TestMIDIPlatformService::TestMIDIPlatformService() :

  mBackgroundThread(NS_GetCurrentThread()),

  mControlInputPort(NS_LITERAL_STRING("b744eebe-f7d8-499b-872b-958f63c8f522"),

                    NS_LITERAL_STRING("Test Control MIDI Device Input Port"),

                    NS_LITERAL_STRING("Test Manufacturer"),

                    NS_LITERAL_STRING("1.0.0"),

                    static_cast<uint32_t>(MIDIPortType::Input)),

  mControlOutputPort(NS_LITERAL_STRING("ab8e7fe8-c4de-436a-a960-30898a7c9a3d"),

                     NS_LITERAL_STRING("Test Control MIDI Device Output Port"),

                     NS_LITERAL_STRING("Test Manufacturer"),

                     NS_LITERAL_STRING("1.0.0"),

                     static_cast<uint32_t>(MIDIPortType::Output)),

  mStateTestInputPort(NS_LITERAL_STRING("a9329677-8588-4460-a091-9d4a7f629a48"),

                      NS_LITERAL_STRING("Test State MIDI Device Input Port"),

                      NS_LITERAL_STRING("Test Manufacturer"),

                      NS_LITERAL_STRING("1.0.0"),

                      static_cast<uint32_t>(MIDIPortType::Input)),

  mStateTestOutputPort(NS_LITERAL_STRING("478fa225-b5fc-4fa6-a543-d32d9cb651e7"),

                       NS_LITERAL_STRING("Test State MIDI Device Output Port"),

                       NS_LITERAL_STRING("Test Manufacturer"),

                       NS_LITERAL_STRING("1.0.0"),

                       static_cast<uint32_t>(MIDIPortType::Output)),

  mAlwaysClosedTestOutputPort(NS_LITERAL_STRING("f87d0c76-3c68-49a9-a44f-700f1125c07a"),

                              NS_LITERAL_STRING("Always Closed MIDI Device Output Port"),

                              NS_LITERAL_STRING("Test Manufacturer"),

                              NS_LITERAL_STRING("1.0.0"),

                              static_cast<uint32_t>(MIDIPortType::Output)),

  mIsInitialized(false)

{

  AssertIsOnBackgroundThread();

}

TestMIDIPlatformService::~TestMIDIPlatformService()

{

  AssertIsOnBackgroundThread();

}

void

TestMIDIPlatformService::Init()

{

  AssertIsOnBackgroundThread();

  if (mIsInitialized) {

    return;

  }

  mIsInitialized = true;

  // Treat all of our special ports as always connected. When the service comes

  // up, prepopulate the port list with them.

  MIDIPlatformService::Get()->AddPortInfo(mControlInputPort);

  MIDIPlatformService::Get()->AddPortInfo(mControlOutputPort);

  MIDIPlatformService::Get()->AddPortInfo(mAlwaysClosedTestOutputPort);

  nsCOMPtr<nsIRunnable> r(new SendPortListRunnable());

  // Start the IO Thread.

  NS_DispatchToCurrentThread(r);

}

void

TestMIDIPlatformService::Open(MIDIPortParent* aPort)

{

  MOZ_ASSERT(aPort);

  MIDIPortConnectionState s = MIDIPortConnectionState::Open;

  if (aPort->MIDIPortInterface::Id() == mAlwaysClosedTestOutputPort.id()) {

    // If it's the always closed testing port, act like it's already opened

    // exclusively elsewhere.

    s = MIDIPortConnectionState::Closed;

  }

  // Connection events are just simulated on the background thread, no need to

  // push to IO thread.

  nsCOMPtr<nsIRunnable> r(new SetStatusRunnable(aPort->MIDIPortInterface::Id(),

                                                aPort->DeviceState(),

                                                s));

  NS_DispatchToCurrentThread(r);

}

void

TestMIDIPlatformService::ScheduleClose(MIDIPortParent* aPort)

{

  MOZ_ASSERT(aPort);

  if (aPort->ConnectionState() == MIDIPortConnectionState::Open) {

    // Connection events are just simulated on the background thread, no need to

    // push to IO thread.

    nsCOMPtr<nsIRunnable> r(new SetStatusRunnable(aPort->MIDIPortInterface::Id(),

                                                  aPort->DeviceState(),

                                                  MIDIPortConnectionState::Closed));

    NS_DispatchToCurrentThread(r);

  }

}

void

TestMIDIPlatformService::Stop()

{

  AssertIsOnBackgroundThread();

}

void TestMIDIPlatformService::ScheduleSend(const nsAString& aPortId)

{

  nsCOMPtr<nsIRunnable> r(new ProcessMessagesRunnable(aPortId));

  NS_DispatchToCurrentThread(r);

}

void TestMIDIPlatformService::ProcessMessages(const nsAString& aPortId)

{

  nsTArray<MIDIMessage> msgs;

  GetMessagesBefore(aPortId, TimeStamp::Now(), msgs);

  for (MIDIMessage msg : msgs) {

    // receiving message from test control port

    if (aPortId == mControlOutputPort.id()) {

      switch (msg.data()[0]) {

      // Hit a note, get a test!

      case 0x90:

        switch (msg.data()[1]) {

        // Echo data/timestamp back through output port

        case 0x00:

        {

          nsCOMPtr<nsIRunnable> r(new ReceiveRunnable(mControlInputPort.id(), msg));

          mBackgroundThread->Dispatch(r, NS_DISPATCH_NORMAL);

          break;

        }

        // Cause control test ports to connect

        case 0x01:

        {

          nsCOMPtr<nsIRunnable> r1(new AddPortRunnable(mStateTestInputPort));

          mBackgroundThread->Dispatch(r1, NS_DISPATCH_NORMAL);

          break;

        }

        // Cause control test ports to disconnect

        case 0x02:

        {

          nsCOMPtr<nsIRunnable> r1(new RemovePortRunnable(mStateTestInputPort));

          mBackgroundThread->Dispatch(r1, NS_DISPATCH_NORMAL);

          break;

        }

        // Test for packet timing

        case 0x03:

        {

          // Append a few echo command packets in reverse timing order, should

          // come out in correct order on other end.

          nsTArray<MIDIMessage> newMsgs;

          nsTArray<uint8_t> msg;

          msg.AppendElement(0x90);

          msg.AppendElement(0x00);

          msg.AppendElement(0x00);

          // PR_Now() returns nanosecods, and we need a double with fractional

          // milliseconds.

          TimeStamp currentTime = TimeStamp::Now();

          for (int i = 0; i <= 5; ++i) {

            // Insert messages with timestamps in reverse order, to make sure

            // we're sorting correctly.

            newMsgs.AppendElement(

              MIDIMessage(msg, currentTime -

                          TimeDuration::FromMilliseconds(i * 2)));

          }

          nsCOMPtr<nsIRunnable> r(new QueueMessagesRunnable(aPortId, newMsgs));

          mBackgroundThread->Dispatch(r, NS_DISPATCH_NORMAL);

          break;

        }

        default:

          NS_WARNING("Unknown Test MIDI message received!");

        }

        break;

        // Sysex tests

      case 0xF0:

        switch (msg.data()[1]) {

          // Echo data/timestamp back through output port

        case 0x00:

        {

          nsCOMPtr<nsIRunnable> r(new ReceiveRunnable(mControlInputPort.id(), msg));

          mBackgroundThread->Dispatch(r, NS_DISPATCH_NORMAL);

          break;

        }

        // Test for system real time messages in the middle of sysex messages.

        case 0x01:

        {

          nsTArray<uint8_t> msgs;

          const uint8_t msg[] = {0xF0, 0x01, 0xF8, 0x02, 0x03, 0x04, 0xF9, 0x05, 0xF7};

          // Can't use AppendElements on an array here, so just do range based loading.

          for (auto& s : msg) {

            msgs.AppendElement(s);

          }

          nsTArray<MIDIMessage> newMsgs;

          MIDIUtils::ParseMessages(msgs, TimeStamp::Now(), newMsgs);

          nsCOMPtr<nsIRunnable> r(new ReceiveRunnable(mControlInputPort.id(), newMsgs));

          mBackgroundThread->Dispatch(r, NS_DISPATCH_NORMAL);

          break;

        }

        default:

          NS_WARNING("Unknown Test Sysex MIDI message received!");

        }

        break;

      }

    }

  }

}