#include "toonz/tframehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/sceneproperties.h"

#include "toutputproperties.h"

#include "toonz/txsheethandle.h"

//=============================================================================

namespace {

/* int getCurrentSceneFrameCount()

  {

    return 100; //

  TApp::instance()->getCurrentScene()->getScene()->getFrameCount();

  }*/

/*void getCurrentScenePlayRange(int &r0, int &r1, int &step)

  {

    /*

    ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

    scene->getProperties()->getPreviewProperties()->getRange(r0, r1, step);

    if(r0>r1)

    {

      r0 = 0;

      r1 = scene->getFrameCount()-1;

    }

    */

/*   r0 = 0;

    r1 = getCurrentSceneFrameCount()-1;

  }*/

bool getCurrentLevelFids(std::vector<tframeid> &fids) {</tframeid>

  /*

TXshSimpleLevel *sl = TApp::instance()->getCurrentLevel()->getSimpleLevel();

if(!sl) return false;

sl->getFids(fids);

*/

  fids.push_back(TFrameId(1));

  return !fids.empty();

}

TFrameId getLastLevelFid() { return TFrameId(1); }

}  // namespace

//=============================================================================

// TFrameHandle

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

TFrameHandle::TFrameHandle()

    : m_frame(-1)

    , m_fid()

    , m_timerId(0)

    , m_previewFrameRate(25)

    , m_frameType(SceneFrame)

    , m_looping(false)

    , m_isPlaying(false)

    , m_scrubRange(0, -1)

    , m_audioColumn(0)

    , m_xsheet(0)

    , m_fps(0)

    , m_frame0(-1)

    , m_frame1(-1) {}

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

TFrameHandle::~TFrameHandle() {}

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

int TFrameHandle::getFrame() const { return m_frame; }

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

void TFrameHandle::setCurrentFrame(int frame) {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    // if(!getCurrentLevelFids(fids)) return;

    if (m_fids.size() <= 0) return;

    if (frame - 1 >= (int)m_fids.size())

      setFid(m_fids.back());

    else

      setFid(m_fids[frame - 1]);

  } else

    setFrame(frame - 1);

}

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

void TFrameHandle::setFrame(int frame) {

  if (m_frame == frame && m_frameType == SceneFrame) return;

  m_frame = frame;

  if (m_frameType != SceneFrame) {

    m_frameType = SceneFrame;

    emit frameTypeChanged();

  }

  emit frameSwitched();

}

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

TFrameId TFrameHandle::getFid() const { return m_fid; }

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

void TFrameHandle::setFid(const TFrameId &fid) {

  if (m_fid == fid && m_frameType == LevelFrame) return;

  m_fid = fid;

  if (m_frameType != LevelFrame) {

    m_frameType = LevelFrame;

    emit frameTypeChanged();

  }

  emit frameSwitched();

}

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

void TFrameHandle::nextFrame() {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    // if(!getCurrentLevelFids(fids)) return;

    if (m_fids.size() <= 0) return;

    std::vector<tframeid>::iterator it;</tframeid>

    it = std::upper_bound(m_fids.begin(), m_fids.end(), m_fid);

    if (it == m_fids.end()) {

      // non c'e' nessun frame del livello oltre m_fid. Non vado oltre al primo

      // frame dopo l'ultimo.

      // TXshSimpleLevel *sl =

      // TApp::instance()->getCurrentLevel()->getSimpleLevel();

      TFrameId fid = m_fids.back();  // sl->index2fid(sl->getFrameCount());

      setFid(fid);

    } else

      setFid(*it);

  } else {

    setFrame(m_frame + 1);

  }

}

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

void TFrameHandle::prevFrame() {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() <= 0) return;

    std::vector<tframeid>::iterator it;</tframeid>

    it = std::lower_bound(m_fids.begin(), m_fids.end(), m_fid);

    // tornando indietro non vado prima del primo frame del livello

    if (it != m_fids.end() && it != m_fids.begin()) {

      --it;

      setFid(*it);

    } else {

      // se sono dopo l'ultimo, vado all'ultimo

      if (!m_fids.empty() && m_fid > m_fids.back()) setFid(m_fids.back());

    }

  } else {

    if (m_frame > 0) setFrame(m_frame - 1);

  }

}

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

void TFrameHandle::firstFrame() {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() <= 0) return;

    setFid(m_fids.front());

  } else {

    /*int r0,r1,step;

getCurrentScenePlayRange(r0,r1,step);*/

    setFrame(m_frame0);

  }

}

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

void TFrameHandle::lastFrame() {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() <= 0) return;

    setFid(m_fids.back());

  } else {

    /*int r0,r1,step;

getCurrentScenePlayRange(r0,r1,step);*/

    if (m_frame1 > 0) setFrame(m_frame1);

  }

}

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

void TFrameHandle::setPlaying(bool isPlaying) {

  if (m_isPlaying == isPlaying) return;

  m_isPlaying = isPlaying;

  emit isPlayingStatusChanged();

}

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

#ifdef LEVO

void TFrameHandle::startPlaying(bool looping) {

  if (m_previewFrameRate == 0) return;

  if (isScrubbing()) stopScrubbing();

  setTimer(m_previewFrameRate);

  m_looping = looping;

  emit playStarted();

}

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

void TFrameHandle::stopPlaying() {

  if (m_timerId != 0) killTimer(m_timerId);

  m_timerId = 0;

  m_looping = false;

  emit playStopped();

}

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

#endif

void TFrameHandle::setTimer(int frameRate) {

  m_previewFrameRate = frameRate;

  if (m_timerId != 0) killTimer(m_timerId);

  int interval = troundp(1000.0 / double(m_previewFrameRate));

  m_timerId    = startTimer(interval);

}

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

void TFrameHandle::timerEvent(QTimerEvent *event) {

  assert(isScrubbing());

  int elapsedTime = m_clock.elapsed();

  int frame       = m_scrubRange.first + elapsedTime * m_fps / 1000;

  int lastFrame   = m_scrubRange.second;

  if (frame >= lastFrame) {

    if (m_frame != lastFrame) setFrame(lastFrame);

    stopScrubbing();

  } else

    setFrame(frame);

}

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

int TFrameHandle::getMaxFrameIndex() const {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() <= 0)

      return -1;

    else

      return m_fids.size() - 1;

  } else

    // return getCurrentSceneFrameCount()-1;

    return m_sceneFrameSize - 1;

}

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

int TFrameHandle::getFrameIndex() const {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() > 0) {

      std::vector<tframeid>::const_iterator it =</tframeid>

          std::find(m_fids.begin(), m_fids.end(), m_fid);

      if (it != m_fids.end())

        return std::distance(m_fids.begin(), it);

      else {

        if (m_fid > m_fids.back())

          return m_fids.size();

        else

          return -1;

      }

    } else

      return -1;

  } else

    return m_frame;

}

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

QString TFrameHandle::getFrameIndexName(int index) const {

  if (m_frameType == LevelFrame) {

    if (m_fid.getNumber() <= 0)

      return "";

    else {

      return QString::number(m_fid.getNumber());

    }

  } else

    return QString::number(m_frame + 1);

}

void TFrameHandle::setFrameIndex(int index) {

  if (m_frameType == LevelFrame) {

    // std::vector<tframeid> fids;</tframeid>

    if (m_fids.size() > 0 && 0 <= index && index < (int)m_fids.size())

      setFid(m_fids[index]);

  } else

    setFrame(index);

}

void TFrameHandle::setFrameIndexByName(const QString &str) {

  int num = str.toInt();

  if (m_frameType == LevelFrame) {

    setFid(TFrameId(num));

  } else

    setFrame(num - 1);

}

void TFrameHandle::scrubColumn(int r0, int r1, TXshSoundColumn *audioColumn,

                               double framePerSecond) {

  m_audioColumn = audioColumn;

  if (!scrub(r0, r1, framePerSecond)) m_audioColumn = 0;

}

void TFrameHandle::scrubXsheet(int r0, int r1, TXsheet *xsheet,

                               double framePerSecond) {

  m_xsheet = xsheet;

  if (!scrub(r0, r1, framePerSecond)) m_xsheet = 0;

}

bool TFrameHandle::scrub(int r0, int r1, double framePerSecond) {

  if (isPlaying() || isScrubbing()) return false;

  bool onlyOneFrame = (r0 == r1);

  if (!isScrubbing() || !onlyOneFrame) emit scrubStarted();

  if (!onlyOneFrame) {

    m_fps        = framePerSecond;

    m_scrubRange = std::make_pair(r0, r1);

  }

  setFrame(r0);

  if (m_audioColumn)

    m_audioColumn->scrub(r0, r1);

  else if (m_xsheet) {

    int i;

    for (i = r0; i <= r1; i++) m_xsheet->scrub(i);

  }

  if (onlyOneFrame) return false;

  m_clock.start();

  m_timerId = startTimer(40);

  return true;

}

void TFrameHandle::stopScrubbing() {

  if (!isScrubbing()) return;

  if (m_timerId > 0) killTimer(m_timerId);

  m_timerId                        = 0;

  m_scrubRange                     = std::make_pair(0, -1);

  if (m_audioColumn) m_audioColumn = 0;

  if (m_xsheet) m_xsheet           = 0;

  m_fps                            = 0;

  emit scrubStopped();

}