#include "Sequencer.h"
#include <MainLoop.h>
#include "Static.h"

Sequencer::Sequencer() :
  Task("SceneSequencer"),
  m_idx(0)
{
  state = Task::Running;
}

void
Sequencer::Scene::start()
{
    for(const char* pattern : patterns) {
        Log.verbose("Starting pattern task %s", pattern);
        MainLoop::instance()->dispatch(InputEvent{InputEvent::StartThing, pattern});
    }
}

void
Sequencer::Scene::stop()
{
    for(const char* pattern : patterns) {
        Log.verbose("Stopping pattern task %s", pattern);
        MainLoop::instance()->dispatch(InputEvent{InputEvent::StopThing, pattern});
    }
}

void
Sequencer::loop() {}

const char*
Sequencer::currentSceneName()
{
    return m_scenes[m_idx].name;
}

const std::vector<Sequencer::Scene>
Sequencer::scenes() const
{
    return m_scenes;
}

void
Sequencer::onStart()
{
}

void
Sequencer::setScenes(std::vector<Scene> &&scenes)
{
  m_idx = 0;
  m_scenes = scenes;
}

void
Sequencer::handleEvent(const InputEvent& evt)
{
    if (evt.intent == InputEvent::ReadyToRoll && !m_scenes.empty()) {
      Log.notice("Starting pattern %s!", m_scenes[m_idx].name);
      for(const char* pattern : m_scenes[m_idx].patterns) {
          Log.verbose("Starting pattern task %s", pattern);
          MainLoop::instance()->dispatch(InputEvent{InputEvent::StartThing, pattern});
      }
    } else if (evt.intent == InputEvent::SetScene && evt.asString() == m_scenes[m_idx].name) {
        return;
    } else if (evt.intent == InputEvent::SetScene) {
        Log.notice("Switching scene to %s!", evt.asString());

        int newIdx = 0;
        bool found = false;
        for(newIdx = 0; newIdx < m_scenes.size(); newIdx++) {
          if (!strcmp(evt.asString(), m_scenes[newIdx].name)) {
              found = true;
              break;
          }
        }

        if (found) {
          m_scenes[m_idx].stop();
          m_idx = newIdx;
          m_scenes[m_idx].start();
        } else {
          Log.notice("Scene not found!");
        }
    }
}

void
Sequencer::doScenes(Args& args, Print& out)
{
  out.println("Available scenes: ");
  for (auto scene : scenes()) {
    out.println(scene.name);
  }
}

static String s;

void
Sequencer::doScene(Args& args, Print& out)
{
  s  = args[1];
  MainLoop::instance()->dispatch(InputEvent{InputEvent::SetScene, s.c_str()});
}

const std::vector<Command>&
Sequencer::commands() const
{
  static const std::vector<Command> _commands = {
    {"scene", &Sequencer::doScene},
    {"scenes", &Sequencer::doScenes}
  };
  return _commands;
}

STATIC_ALLOC(Sequencer);
STATIC_TASK(Sequencer);