#include <QTime>
#include <QJsonArray>
#include <QStringList>
#include <QDebug>

#include "Segment.h"
#include "Season.h"
#include "Episode.h"
#include "Scene.h"
#include "Shot.h"
#include "VideoFrame.h"

Segment::Segment(Segment *parentSegment)
  : m_parentSegment(parentSegment)
{
}

Segment::Segment(qint64 position, Segment *parentSegment, Source source)
  : m_position(position),
    m_source(source),
    m_parentSegment(parentSegment)
{
}

Segment::~Segment()
{
  qDeleteAll(m_childSegments);
}

void Segment::read(const QJsonObject &json)
{
  m_position = json["pos"].toInt();

  m_source = static_cast<Source>(json["source"].toInt());

  m_childSegments.clear();
  QJsonArray segArray;
  QStringList segList;
  segList << "seasons" << "episodes" << "scenes" << "shots" << "vFrames";
    
  for (int i = 0; i < segList.size(); i++)
    if (json.contains(segList[i])) {
      segArray = json[segList[i]].toArray();
      for (int j = 0; j < segArray.size(); j++) {
	QJsonObject segObject = segArray[j].toObject();
	Segment *segment = 0;

	if (segList[i] == "seasons")
	  segment = new Season(this);
	else if (segList[i] == "episodes")
	  segment = new Episode(this);
	else if (segList[i] == "scenes")
	  segment = new Scene(this);
	else if (segList[i] == "shots")
	  segment = new Shot(this);
	else if (segList[i] == "vFrames")
	  segment = new VideoFrame(this);
	
	segment->read(segObject);
	appendChild(segment);
      }
      break;
    }

  return;
}

void Segment::write(QJsonObject &json) const
{
  json["pos"] = m_position;
  json["source"] = m_source;

  if (childCount() > 0) {
    QString segType = "segments";
    if (dynamic_cast<Season *>(m_childSegments[0]))
      segType = "seasons";
    else if (dynamic_cast<Episode *>(m_childSegments[0]))
      segType = "episodes";
    else if (dynamic_cast<Scene *>(m_childSegments[0]))
      segType = "scenes";
    else if (dynamic_cast<Shot *>(m_childSegments[0]))
      segType = "shots";
    else if (dynamic_cast<VideoFrame *>(m_childSegments[0]))
      segType = "vFrames";

    QJsonArray segArray;
    foreach (Segment *segment, m_childSegments) {
      QJsonObject segObject;
      segment->write(segObject);
      segArray.append(segObject);
    }

    json[segType] = segArray;
  }
  
  return;
}

////////////////////////////////////////
// methods dedicated to tree handling //
////////////////////////////////////////

Segment * Segment::child(int row)
{
  return m_childSegments.value(row);
}

void Segment::appendChild(Segment *childSegment)
{
  m_childSegments.append(childSegment);
}

void Segment::insertChild(int row, Segment *segment)
{
  m_childSegments.insert(row, segment);
}

void Segment::removeChild(int row)
{
  m_childSegments.removeAt(row);
}

int Segment::childCount() const
{
  return m_childSegments.count();
}

int Segment::row() const
{
  if (m_parentSegment)
    return m_parentSegment->m_childSegments.indexOf(const_cast<Segment *>(this));

  return 0;
}

Segment * Segment::parent()
{
  return m_parentSegment;
}

void Segment::splitChildren(QList<Segment *> &subList1, QList<Segment *> &subList2, int pos, Segment *newParent)
{
  int size = childCount();

  for (int i = 0; i < size; i++) {
    if (i < pos)
      subList1.append(m_childSegments[i]);
    else {
      m_childSegments[i]->setParent(newParent);
      subList2.append(m_childSegments[i]);
    }
  }
}

///////////////
// modifiers //
///////////////

void Segment::setPosition(qint64 position)
{
  m_position = position;
}

void Segment::setChildren(const QList<Segment *> &children)
{
  m_childSegments = children;
}

void Segment::setParent(Segment *parent)
{
  m_parentSegment = parent;
}

void Segment::setSource(Source source)
{
  m_source = source;
}

void Segment::clearChildren()
{
  m_childSegments.clear();
}

///////////////
// accessors //
///////////////

QString Segment::getFormattedPosition() const
{
  QString m_timeFormat;
  int ms = m_position % 1000;
  int secPos = m_position / 1000;

  QTime totalTime((secPos / 3600) % 60, (secPos / 60) % 60, secPos % 60, ms);

  if (secPos > 3600)
    m_timeFormat = "hh:mm:ss.zzz";
  else
    m_timeFormat = "mm:ss.zzz";

  return totalTime.toString(m_timeFormat);
}

qint64 Segment::getPosition() const
{
  return m_position;
}

QList<Segment *> Segment::getChildren() const
{
  return m_childSegments;
}

void Segment::setEnd(qint64 end)
{
  Q_UNUSED(end);
}

int Segment::getNumber() const
{
  return -1;
}

qint64 Segment::getEnd() const
{
  return -1;
}

QString Segment::getLabel() const
{
  return QString();
}

void Segment::setLabel(const QString &label)
{
  Q_UNUSED(label);
}

int Segment::getCamera(Segment::Source source) const
{
  Q_UNUSED(source);
  
  return -1;
}

int Segment::getHeight() const
{
  if (childCount() == 0)
    return 0;
  
  return 1 + m_childSegments[0]->getHeight();
}

Segment::Source Segment::getSource() const
{
  return m_source;
}

void Segment::containsSpeech(bool &flag) const
{
  VideoFrame *vFrame;
  Segment *tmp = const_cast<Segment *>(this);

  if ((vFrame = dynamic_cast<VideoFrame *>(tmp)) && !vFrame->getSpeaker(VideoFrame::Ref).isEmpty()) {
    flag = true;
    return;
  }
  else
    for (int i(0); i < tmp->childCount(); i++)
      tmp->child(i)->containsSpeech(flag);
}

int Segment::childIndexFromPosition(qint64 position)
{
  int size = childCount();
  bool found = false;
  int iSup(size-1);
  int iInf(0);
  int iMed(-1);
  qreal currPosition;
  
  while (!found && iSup >= iInf) {
    iMed = (iSup + iInf) / 2;
    currPosition = m_childSegments[iMed]->getPosition();
    if (position == currPosition)
      found = true;
    else if (position < currPosition)
      iSup = iMed - 1;
    else if (position > currPosition)
      iInf = iMed + 1;
  }

  // adjust index if element not found
  while (iMed < size-1 && m_childSegments[iMed]->getPosition() <= position)
    iMed++;

  while (iMed > 0 && m_childSegments[iMed]->getPosition() > position)
    iMed--;
  
  return iMed;
}