#include <QVBoxLayout>

#include "ModelView.h"
#include "Shot.h"
#include "VideoFrame.h"

#include <QDebug>

ModelView::ModelView(ProjectModel *project, int nVignettes, QWidget *parent)
  : QWidget(parent),
    m_currEpisode(0),
    m_project(project),
    m_nVignettes(nVignettes),
    m_playerPaused(true)
{
  m_treeView = new QTreeView;
  m_treeView->expandAll();

  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(m_treeView);
  setLayout(layout);

  m_treeView->setModel(m_project);
  m_selection = m_treeView->selectionModel();

  connect(m_selection, SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)),
	  this, SLOT(updatePlayer(const QModelIndex &, const QModelIndex &)));
}

void ModelView::adjust()
{
  m_treeView->resizeColumnToContents(0);
  m_treeView->resizeColumnToContents(1);
}

void ModelView::initPlayer()
{
  QModelIndex seasonIndex = m_project->index(0, 0);
  updatePlayer(seasonIndex, QModelIndex());
}

/////////////////////////////////////////////
// slot called when clicking on model view //
/////////////////////////////////////////////

void ModelView::updatePlayer(const QModelIndex &current, const QModelIndex &previous)
{
  Q_UNUSED(previous);

  Shot *shot;

  // scroll to selected segment
  m_treeView->scrollTo(current, QAbstractItemView::PositionAtCenter);

  // selected segment
  Segment *segment = static_cast<Segment *>(current.internalPointer());

  // emit signals when encountering shot
  if ((shot = dynamic_cast<Shot *>(segment)))
    emit currentShot(genPositionList(segment));

  updateCurrentEpisode(segment);
  emit setPlayer(m_currEpisode->getFName(), m_currEpisode->getResolution());
  emit setPlayerPosition(segment->getPosition());

  if (m_playerPaused) {
   
    qint64 position = segment->getPosition();
    VideoFrame *vFrame;
    int i;

    // retrieve current video frame
    while (!(vFrame = dynamic_cast<VideoFrame *>(segment))) {

      // closest segment index to current player position
      i = segment->childIndexFromPosition(position);

      // select possible children
      segment = segment->child(i);
    }

    emit displaySubtitle(vFrame->getSub());
  }
}

///////////////////////////////////////////
// slot called when player state changes //
///////////////////////////////////////////

void ModelView::playerPaused(bool pause)
{
  m_playerPaused = pause;
}

//////////////////////////////////////////////
// slot called when player position changes //
//////////////////////////////////////////////

void ModelView::positionChanged(qint64 position)
{
  int i(-1);
  QModelIndex index;
  QModelIndex siblingIndex;
  VideoFrame *vFrame;

  m_selection->clearSelection();

  Segment *segment = m_currEpisode;

  // retrieve segment to select
  int depth = 0;
  while (depth++ < m_depth) {

    // closest segment index to current player position
    i = segment->childIndexFromPosition(position);

    // select possible children
    segment = segment->child(i);
  }

  // model indexes to select
  index = m_project->indexFromSegment(segment);
  siblingIndex = m_project->sibling(i, 1, index);
  
  // segment selection
  m_selection->setCurrentIndex(index, QItemSelectionModel::Select);
  m_selection->setCurrentIndex(siblingIndex, QItemSelectionModel::Select);

  // retrieve current video frame
  while (!(vFrame = dynamic_cast<VideoFrame *>(segment))) {

    // closest segment index to current player position
    i = segment->childIndexFromPosition(position);

    // select possible children
    segment = segment->child(i);
  }

  emit displaySubtitle(vFrame->getSub());
}

///////////////////////////////////
// slot called when pressing key //
///////////////////////////////////

void ModelView::keyPressEvent(QKeyEvent *event)
{
  Segment *segment = static_cast<Segment *>(m_selection->currentIndex().internalPointer());

  if (event->key() == Qt::Key_Return && dynamic_cast<VideoFrame *>(segment))
    emit insertShot(segment);
  else if (event->key() == Qt::Key_Backspace && dynamic_cast<Shot *>(segment))
    emit removeShot(segment);
  else if (event->key() == Qt::Key_Return && dynamic_cast<Shot *>(segment))
    emit editSimShots(segment);
}

///////////////////////////////////////////////////
// slots called when entering in annotation mode //
///////////////////////////////////////////////////

void ModelView::initShotAnnot(bool checked)
{
  Segment *segment = static_cast<Segment *>(m_selection->currentIndex().internalPointer());

  if (checked)
    emit initShotLevel(segment);
}

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

QString ModelView::getCurrentEpisodeFName() const
{
  return m_currEpisode->getFName();
}

/////////////////////
// private methods //
/////////////////////

void ModelView::updateCurrentEpisode(Segment *segment)
{
  Episode *episode = 0;

  // looking for corresponding episode
  Segment *tmp = segment;

  // searching among parent segments
  while (tmp != 0 && !(episode = dynamic_cast<Episode *>(tmp)))
    tmp = tmp->parent();

  // if not found, searching among child segments
  if (!tmp) {
    tmp = segment;
    while (tmp != 0 && !(episode = dynamic_cast<Episode *>(tmp)))
      tmp = tmp->child(0);
  }

  if (episode != m_currEpisode) {
    m_currEpisode = episode;
  }
}

QList<qint64> ModelView::genPositionList(Segment *segment)
{
  QList<qint64> positionList;
  qint64 segmentPosition;

  int iFirst = segment->row() - m_nVignettes / 2;
  int iLast = segment->row() + m_nVignettes / 2;

  for (int i(iFirst); i <= iLast; i++) {
    if (i >= 0 && i < segment->parent()->childCount()) {
      segmentPosition = segment->parent()->child(i)->getPosition();
      positionList.push_back(segmentPosition);
    }
    else
      positionList.push_back(-1);
  }

  return positionList;
}

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

void ModelView::setDepth(int depth)
{
  m_depth = depth - 2;
  m_treeView->expandToDepth(m_depth);
  adjust();
}