Playback.h

#ifndef _PLAYBACK_H_
#define _PLAYBACK_H_

#pragma once

#include <memory>
#include <chrono>

#include <LumiverseCore.h>
#include "Timeline.h"
#include "Layer.h"
#include "Programmer.h"


namespace Lumiverse {
namespace ShowControl{
  class Layer;
  class CueList;
  
  class Playback
  {
  public:
    Playback(Rig* rig, float gm = 1.0f);

    Playback(Rig* rig, string filename);

    // Changes to make to playback: Playback must now maintain a list of layers
    // Layers are update in the playback update loop with layer->update()
    // Each layer now takes over the cue playback controls
    // Playback also maintains the master list of CueLists for reference by the layers.

    // Deletes a playback object.
    ~Playback();

    void start();

    void stop();

    bool isRunning() { return m_running; }

    // void setRefreshRate(unsigned int rate);

    void update();

    bool addLayer(shared_ptr<Layer> layer);

    shared_ptr<Layer> getLayer(string name);

    void deleteLayer(string name);

    bool addTimeline(string id, shared_ptr<Timeline> tl);

    void deleteTimeline(string id);

    shared_ptr<Timeline> getTimeline(string id);

    map<string, shared_ptr<Timeline> >& getTimelines();

    bool attachToRig(int pid = 1);

    bool detachFromRig();

    const unique_ptr<Programmer>& getProgrammer() { return m_prog; }

    bool save(string filename, bool overwrite = false);

    JSONNode toJSON();

    Rig* getRig() { return m_rig; }

    vector<string> getLayerNames();

    vector<string> getTimelineNames();

    const map<string, shared_ptr<Layer> >& getLayers() { return m_layers; }

    bool loadJSON(JSONNode node);

    int getNumLayers();

    bool storeGroup(string name, DeviceSet group, bool overwrite = false);

    bool storeDynamicGroup(string name, DynamicDeviceSet group, bool overwrite = false);

    bool deleteGroup(string name);

    bool deleteDynamicGroup(string name);

    DeviceSet getGroup(string name);

    DynamicDeviceSet getDynamicGroup(string name);

    bool groupExists(string name);

    bool dynamicGroupExists(string name);

    const map<string, DeviceSet>& getGroups() { return m_groups; }

    const map<string, DynamicDeviceSet>& getDynamicGroups() { return m_dynGroups; }

    void setGrandmaster(float val);

    float getGrandmaster() { return m_grandmaster; }

    bool addCueList(shared_ptr<CueList> cueList);

    shared_ptr<CueList> getCueList(string id);

    void deleteCueList(string id);

    bool addCueListToLayer(string cueListId, string layerName, bool resetCurrentCue = true);

    void removeCueListFromLayer(string layerName);

    vector<string> getCueListNames();

    int getNumCueLists();

  private:
    map<string, shared_ptr<Layer> > m_layers;

    map<string, Device*> m_state;

    map<string, DeviceSet> m_groups;

    map<string, DynamicDeviceSet> m_dynGroups;

    map<string, shared_ptr<Timeline> > m_timelines;

    map<string, shared_ptr<CueList> > m_cueLists;

    // Does the updating of the rig while running.
    // unique_ptr<thread> m_updateLoop;

    bool m_running;

    int m_funcId;

    float m_grandmaster;

    // Refresh rate used by the update loop.
    // unsigned int m_refreshRate;

    // Loop time in seconds
    // float m_loopTime;

    Rig* m_rig;

    unique_ptr<Programmer> m_prog;

    bool load(string filename);
  };
}
}
#endif