#include <QProgressDialog>
#include <QLabel>
#include <QGridLayout>
#include <QFile>
#include <QFileDialog>
#include <QRegularExpression>
#include <QProcess>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <QDebug>
#include <iostream>
#include <cstdlib>

#include "MovieAnalyzer.h"
#include "ProjectModel.h"

using namespace cv;
using namespace std;

MovieAnalyzer::MovieAnalyzer(QWidget *parent)
  : QWidget(parent)
{
  m_processor = new VideoFrameProcessor;
}

MovieAnalyzer::~MovieAnalyzer()
{
}

bool MovieAnalyzer::extractVideoFrames(const QString &fName)
{
  int id;

  m_cap.release();
  m_cap.open(fName.toStdString());

  QProgressDialog progress(tr("Extracting frames..."), tr("Cancel"), 0, m_cap.get(CV_CAP_PROP_FRAME_COUNT), this);
  progress.setWindowModality(Qt::WindowModal);

  emit setResolution(QSize(m_cap.get(CV_CAP_PROP_FRAME_WIDTH), m_cap.get(CV_CAP_PROP_FRAME_HEIGHT)));
  emit setFps(m_cap.get(CV_CAP_PROP_FPS));

  while (m_cap.grab()) {
    id = m_cap.get(CV_CAP_PROP_POS_FRAMES);
    progress.setValue(id);

    if (progress.wasCanceled())
      return false;

    emit appendVideoFrame(id, m_cap.get(CV_CAP_PROP_POS_MSEC));
  }

  return true;
}

bool MovieAnalyzer::extractShots(const QString &fName, int histoType, int nVBins, int nHBins, int nSBins, int metrics, qreal threshold1, qreal threshold2, int nVBlock, int nHBlock, bool viewProgress)
{
  m_cap.release();
  m_cap.open(fName.toStdString());
  
  // current frame
  Mat frame;

  // subimages of current frame
  QVector<Mat> blocks(nVBlock * nHBlock);

  // corresponding local histograms
  QVector<Mat> locHisto(nVBlock * nHBlock);

  // distances between current and previous local histograms
  QVector<qreal> distance(nVBlock * nHBlock);

  // distance between current and past frame
  qreal dist;

  // frames considered to detect cut
  QList<qreal> window;

  // current frame position and index
  qint64 position(0);
  int n(0);

  // previous frame position
  qint64 prevPosition(0);

  // indicates that no more frame is available in video capture
  bool open(true);

  // normalized local copies of thresholds
  qreal thresh1(threshold1 / 100.0);
  qreal thresh2(threshold2 / 100.0);

  // activate appropriate metrics
  switch (metrics) {
  case 4:
    m_processor->activL1();
    break;
  case 5:
    m_processor->activL2();
    break;
  case CV_COMP_CORREL:
    m_processor->activCorrel();
    break;
  case CV_COMP_CHISQR:
    m_processor->activChiSqr();
    break;
  case CV_COMP_INTERSECT:
    m_processor->activIntersect();
    break;
  case CV_COMP_HELLINGER:
    m_processor->activHellinger();
    break;
  }
  
  // progress bar
  QProgressDialog progress(tr("Extracting shots..."), tr("Cancel"), 0, m_cap.get(CV_CAP_PROP_FRAME_COUNT), this);
  if (viewProgress) {
    progress.setWindowModality(Qt::WindowModal);
  }

  while (open) {

    // retrieve frame position
    n = m_cap.get(CV_CAP_PROP_POS_FRAMES);
    position = m_cap.get(CV_CAP_PROP_POS_MSEC);

    open = m_cap.read(frame);

    if (open) {

      // retrieving previous shot frame blocks
      blocks = splitImage(frame, nVBlock, nHBlock);

      // looping over frame blocks
      for (int i(0); i < blocks.size(); i++) {

	// compute  V/HS/HSV histogram for each frame block
	switch (histoType) {
	case 0:
	  locHisto[i] = m_processor->genVHisto(blocks[i], nVBins);
	  break;
	case 1:
	  locHisto[i] = m_processor->genHsHisto(blocks[i], nHBins, nSBins);
	  break;
	case 2:
	  locHisto[i] = m_processor->genHsvHisto(blocks[i], nHBins, nSBins, nVBins);
	  break;
	}

	// compute distance from previous frame for each block
	if (!m_prevLocHisto.isEmpty())
	  distance[i] = m_processor->distanceFromPrev(locHisto[i], m_prevLocHisto[i]);
      }
     
      dist = meanDistance(distance);

      /*** for displaying purpose ***/
      /* imshow("test1", frame);
      waitKey(0);

      qDebug();
      for (int i(0); i < nHBlock; i++) {
	for (int j(0); j < nVBlock; j++) {
	  printf("%4.4f\t", 1 - distance[i * nVBlock + j]);
	}
	cout << endl;
      }

      qDebug();
      qDebug() << (1 - dist); */
  
      // append current distance to the window
      window.push_back(dist);

      if (window.size() > 3)
	window.pop_front();

      // insert shot at current position
      if (window[0] <= thresh2 && window[1] >= thresh1 && window[2] <= thresh2) {
	emit insertShot(prevPosition, Segment::Automatic);
      }

      // updating previous local histograms to current ones
      m_prevLocHisto.resize(blocks.size());
      m_prevLocHisto = locHisto;

      // updating previous position to current
      prevPosition = position;
    }

    // update progress bar
    if (viewProgress) {
      progress.setValue(n);
      if (progress.wasCanceled())
	return false;
    }
  }

  return true;
}

bool MovieAnalyzer::labelSimilarShots(QString fName, int histoType, int nVBins, int nHBins, int nSBins, int metrics, qreal maxDist, int windowSize, const QList<qint64> &shotPositions, int nVBlock, int nHBlock, bool viewProgress)
{

  m_cap.release();
  m_cap.open(fName.toStdString());

  // distance matrix between shots
  Mat dist(shotPositions.size(), shotPositions.size(), CV_32FC1, Scalar(-1.0));

  // previous and current shot frame
  Mat prevShotFrame;
  Mat currShotFrame;

  // subimages of current and past frames
  QVector<Mat> prevBlocks;
  QVector<Mat> currBlocks;

  // local histogram of each frame block
  QVector<Mat> locHisto(nVBlock * nHBlock);

  // accumulator of previous lists of local histograms
  QList<QVector<Mat>> locHistoBuffer;

  // distance between first frame of current shot and last frame of past shot
  QVector<qreal> distance(nVBlock * nHBlock);

  /*** for displaying purpose ***/
  QList<Mat> frameBuffer;

  // frame duration
  // doesn't work anymore after updating Ubuntu
  // int frameDur = 1 / m_cap.get(CV_CAP_PROP_FPS) * 1000;
  int frameDur = 1 / 25.0 * 1000;
  
  // distance between local histograms
  qreal locDistance;
  // minimum distance from current frame observed so far
  qreal minDistance;
  // corresponding index
  int jMin;

  // current camera label
  int nCamera(0);
  
  // camera label for each shot
  QVector<int> shotCamera(shotPositions.size());

  // activate appropriate metrics
  switch (metrics) {
  case 4:
    m_processor->activL1();
    break;
  case 5:
    m_processor->activL2();
    break;
  case CV_COMP_CORREL:
    m_processor->activCorrel();
    break;
  case CV_COMP_CHISQR:
    m_processor->activChiSqr();
    break;
  case CV_COMP_INTERSECT:
    m_processor->activIntersect();
    break;
  case CV_COMP_HELLINGER:
    m_processor->activHellinger();
    break;
  }

  // progress bar
  QProgressDialog progress(tr("Retrieving similar shots..."), tr("Cancel"), 0, shotPositions.size(), this);
  if (viewProgress)
    progress.setWindowModality(Qt::WindowModal);

  // normalizing max distance required to link two shots
  maxDist /= 100.0;

  // looping over shot positions
  shotCamera[0] = nCamera;

  for (int i(1); i < shotPositions.size(); i++) {
    
    /****************************/
    /* processing previous shot */
    /****************************/

    m_cap.set(CV_CAP_PROP_POS_MSEC, shotPositions[i] - frameDur);
    m_cap >> prevShotFrame;
    
    // retrieving previous shot frame blocks
    prevBlocks = splitImage(prevShotFrame, nVBlock, nHBlock);

    // resizing local histograms vector if necessary
    if (prevBlocks.size() != nVBlock * nHBlock)
      locHisto.resize(prevBlocks.size());

    // looping over previous shot frame blocks
    for (int j(0); j < prevBlocks.size(); j++)

      // compute  V/HS/HSV histogram for each block of previous shot last frame
      switch (histoType) {
      case 0:
	locHisto[j] = m_processor->genVHisto(prevBlocks[j], nVBins);
	break;
      case 1:
	locHisto[j] = m_processor->genHsHisto(prevBlocks[j], nHBins, nSBins);
	break;
      case 2:
	locHisto[j] = m_processor->genHsvHisto(prevBlocks[j], nHBins, nSBins, nVBins);
       break;
      }

    /*** for displaying purpose ***/
    /* Mat frameCopy;
    prevShotFrame.copyTo(frameCopy);
    frameBuffer.push_front(frameCopy);
    if (frameBuffer.size() == windowSize + 1)
    frameBuffer.pop_back(); */

    // saving list of corresponding histograms
    locHistoBuffer.push_front(locHisto);

    // update buffer boundaries
    if (locHistoBuffer.size() == windowSize + 1)
      locHistoBuffer.pop_back();
    
    /***************************/
    /* processing current shot */
    /***************************/

    m_cap >> currShotFrame;

    /*** for displaying purpose ***/
    // imshow("present", currShotFrame);

    // retrieving current shot frame blocks
    currBlocks = splitImage(currShotFrame, nVBlock, nHBlock);

    // resizing local histograms vector if necessary
    if (currBlocks.size() != nVBlock * nHBlock) {
      locHisto.resize(currBlocks.size());
      distance.resize(currBlocks.size());
    }

    // looping over current shot frame blocks
    for (int j(0); j < currBlocks.size(); j++)

      // compute  V/HS/HSV histogram for each block of current shot last frame
      switch (histoType) {
      case 0:
	locHisto[j] = m_processor->genVHisto(currBlocks[j], nVBins);
	break;
      case 1:
	locHisto[j] = m_processor->genHsHisto(currBlocks[j], nHBins, nSBins);
	break;
      case 2:
	locHisto[j] = m_processor->genHsvHisto(currBlocks[j], nHBins, nSBins, nVBins);
       break;
      }

    // compute distance between current and past frame local histograms
    minDistance = 1.0;
    jMin = 0;

    for (int j(0); j < locHistoBuffer.size(); j++) {
      
      // retrieving past list of local histograms
      QVector<Mat> prevLocHisto = locHistoBuffer[j];

      // looping over list of local histograms and computing local distances
      for (int k(0); k < prevLocHisto.size(); k++)
	distance[k] = m_processor->distanceFromPrev(locHisto[k], prevLocHisto[k]);

      // averaging local distances
      locDistance = meanDistance(distance);

      /*** for displaying purpose ***/
      /* qDebug();
      
      for (int k(0); k < nHBlock; k++) {
	for (int l(0); l < nVBlock; l++) {
	  printf("%4.4f\t", 1 - distance[k * nVBlock + l]);
	}
	cout << endl;
      }

      qDebug();
      qDebug() << (1 - locDistance);
      imshow("past", frameBuffer[j]);
      waitKey(0); */
      
      if (locDistance < minDistance) {
	minDistance = locDistance;
	jMin = j;
      }

      // updating distance matrix
      dist.at<float>(i, i-j-1) = locDistance;
    }

    // similar shot retrieved among previous shots
    if (minDistance <= maxDist) {
      int iSim = i - (jMin + 1);
      shotCamera[i] = shotCamera[iSim];
      emit labelSimShot(shotPositions[iSim], shotCamera[iSim], Segment::Automatic);
      emit labelSimShot(shotPositions[i], shotCamera[i], Segment::Automatic);
    }
    // no similar shot retrieved: new camera label
    else
      shotCamera[i] = nCamera++;
    
    // updating progress bar
    if (viewProgress) {
      progress.setValue(i);
      if (progress.wasCanceled())
	return false;
    }
  }

  return true;
}

bool MovieAnalyzer::localSpkDiar(QList<QPair<qint64, qint64>> subBound, QMap<QString, QList<QPair<int, qreal>>> shotPatterns, QMap<QString, QList<QPair<qint64, qint64>>> strictShotPattBound, UtteranceTree::DistType dist, bool norm, UtteranceTree::AgrCrit agr, UtteranceTree::PartMeth partMeth, bool weight, bool sigma, const QString &baseName)
{
  QMap<QString, QList<QPair<int, qreal>>>::const_iterator it = shotPatterns.begin();
  QMap<QString, QString> uttLabels; // speaker label assigned to each utterance

  QString pattLabel;                // pattern label
  int uttIdx;                       // utterance index
  qreal uttStart;                   // utterance beginning in s
  qreal uttEnd;                     // utterance ending in s
  UtteranceTree tree;               // dendogram corresponding to local clustering  
  QList<QList<int>> partition;      // optimal partition of the tree
  qreal beginning, end;             // boundaries of movie subpart considered
  QString workPath("spkDiarization/");
  QProcess process;
  QString program;
  QStringList arguments;
  QString args;
  int out;

  m_baseName = baseName;

  qDebug() << "Local agglomerative clustering...";

  // initializing boundaries
  beginning = subBound[subBound.size() - 1].second / 1000.0;
  end = subBound[0].first / 1000.0;

  // output file
  QString fName = workPath + "lblLocalSegmentation/" + m_baseName + ".lbl";

  QFile lblFile(fName);

  if (!lblFile.open(QIODevice::WriteOnly | QIODevice::Text))
    return false;

  QTextStream lblOut(&lblFile);

  // parameterizing tree
  tree.setDist(dist);
  tree.setAgr(agr);
  tree.setPartMeth(partMeth);

  // setting covariance matrix
  if (sigma)
    CovInv = pinv(Sigma);
  else
    CovInv = pinv(CovW);

  // normalize E if necessary
  if (norm)
    normalize(dist);

  // looping over shot patterns
  while (it != shotPatterns.end()) {

    // current pattern label
    pattLabel = it.key();

    // pattern boundaries
    QList<QPair<qint64, qint64>> shotPattBound = strictShotPattBound[pattLabel];
    
    //  utterances covered by current pattern
    QList<QPair<int, qreal>> utter = it.value();

    // indices of utterances in current pattern
    arma::umat V(1, utter.size());

    for (int i(0); i < utter.size(); i++)
      V(0, i) = utter[i].first;

    // matrix containing utterance i-vectors for current pattern
    arma::mat S = E.rows(V);

    // weighting utterances
    arma::mat W(1, utter.size(), arma::fill::ones);

    if (weight)
      for (int i(0); i < utter.size(); i++)
	W(0, i) = utter[i].second;
    else
      W.ones(1, utter.size());
    
    W /= arma::accu(W);

    // setting tree
    tree.setTree(S, W, CovInv);

    // retrieving optimal partition
    partition = tree.getPartition();
    
    // looping over partition for labeling purpose
    for (int i(0); i < partition.size(); i++) {
      for (int j(0); j < partition[i].size(); j++) {

	// index of current utterance
	uttIdx = utter[partition[i][j]].first;

	// adjusting utterance boundaries to shot pattern ones
	QPair<qint64, qint64> pair = adjustSubBoundaries(subBound[uttIdx].first, subBound[uttIdx].second, shotPattBound);
	uttStart = static_cast<qreal>(pair.first) / 1000.0;
	uttEnd = static_cast<qreal>(pair.second) / 1000.0;

	// labelling current utterance
	QString currSpk = pattLabel + "_S" + QString::number(i);
	lblOut << uttStart << " " << uttEnd << " " << currSpk << endl;
	
	emit setSpeaker(static_cast<qint64>(uttStart * 1000),
			static_cast<qint64>(uttEnd * 1000),
			currSpk,
			VideoFrame::Hyp1);

	// updating boundaries of speech segments
	if (uttStart < beginning)
	  beginning = uttStart;

	if (uttEnd > end)
	  end = uttEnd;
      }
    }
    
    it++;
  }

  qDebug() << "Done.";

  // converting hypotheses .lbl file into .rttm one
  program = "perl";
  arguments << workPath + "scripts/SpkMoulinette.pl" << workPath + "lblLocalSegmentation/" + m_baseName + ".lbl" << workPath + "rttmTmp/" + m_baseName + ".rttm";
  process.start(program, arguments);
  process.waitForFinished();
  arguments.clear();

  // evaluating hypotheses
  program = "perl ";
  args = workPath + "scripts/md-eval-v21.pl" + " -af -m -1 -c 0.25 -r " + workPath + "data/ref/seg/" + m_baseName + ".rttm" + " -s " + workPath + "rttmTmp/" + m_baseName + ".rttm" + " -u " + workPath + "data/ref/local/" + m_baseName + ".uem > " + workPath + "score/local/" + m_baseName + ".nistres";
  out = std::system(qPrintable(program + args));

  return true;
}

bool MovieAnalyzer::globalSpkDiar(const QString &baseName)
{
  UtteranceTree tree;                    // dendogram corresponding to global clustering  
  QList<QList<int>> partition;           // selected partition of the tree
  QList<QPair<int, qreal>> spkFeatures;  // speakers references and weights
  qreal weight;
  QMap<QString, qreal> spkWeight;
  QString speaker;

  m_baseName = baseName;

  // weighting speakers
  QMap<QString, QList<QPair<qreal, qreal>>>::const_iterator it = m_utterances.begin();

  while (it != m_utterances.end()) {

    speaker = it.key();
    QList<QPair<qreal, qreal>> utterances = it.value();
    
    spkWeight[speaker] = 0.0;

    for (int i(0); i < utterances.size(); i++)
      spkWeight[speaker] += utterances[i].second - utterances[i].first;

    it++;
  }

  // setting features
  it = m_utterances.begin();
  spkFeatures.clear();

  while (it != m_utterances.end()) {

    speaker = it.key();
    weight = spkWeight[speaker];
    spkFeatures.push_back(QPair<int, qreal>(m_speakers.indexOf(speaker), weight));

    it++;
  }

  // sending parameters to tree monitor
  m_treeMonitor = new SpkDiarMonitor(900, 300, true);
  m_treeMonitor->setDiarData(E, Sigma, CovW);
  m_treeMonitor->setSpeakers(m_speakers, spkWeight);
  m_treeMonitor->getCurrentPattern(spkFeatures);
  m_treeMonitor->show();

  // receiving playing signal from dendogram widget
  connect(m_treeMonitor, SIGNAL(playSub(QList<int>)), this, SLOT(playSpeakers(QList<int>)));

  // get partition for default parameters
  connect(m_treeMonitor, SIGNAL(setSpeakerPartition(QList<QList<int>>)), this, SLOT(setSpeakerPartition(QList<QList<int>>)));

  // sending scores obtained to diarization monitor
  connect(this, SIGNAL(setLocalDer(const QString &)), m_treeMonitor, SLOT(setLocalDer(const QString &)));
  connect(this, SIGNAL(setGlobalDer(const QString &)), m_treeMonitor, SLOT(setGlobalDer(const QString &)));
  
  m_treeMonitor->exportResults();
  
  return true;
}

bool MovieAnalyzer::localSpkDiarBaseline(QMap<QString, QList<QPair<int, qreal>>> shotPatterns, QList<QPair<qint64, qint64>> subBound, QMap<QString, QList<QPair<int, qreal>>> shotUtterances, QMap<QString, QList<QPair<qint64, qint64>>> strictShotPattBound, const QString &baseName)
{
  QMap<QString, QList<QPair<int, qreal>>>::const_iterator it = shotPatterns.begin();
  QString patternLabel;
  QString currSpk;
  QStringList labelList;
  QString firstLabel;
  QString secondLabel;
  qreal uttStart;
  qreal uttEnd;
  QPair<QStringList, QStringList> patternShots;
  QString workPath("spkDiarization/");
  QProcess process;
  QString program;
  QStringList arguments;
  QString args;
  int out;

  m_baseName = baseName;

  // output file
  QString fName = workPath + "lblLocalSegmentation/" + m_baseName + ".lbl";

  QFile lblFile(fName);

  if (!lblFile.open(QIODevice::WriteOnly | QIODevice::Text))
    return false;

  QTextStream lblOut(&lblFile);

  // looping over shot patterns
  while (it != shotPatterns.end()) {

    // current pattern label
    patternLabel = it.key();

    // pattern boundaries
    QList<QPair<qint64, qint64>> shotPattBound = strictShotPattBound[patternLabel];

    // retrieving each pattern part
    labelList = patternLabel.split("_");
    firstLabel = labelList[0];
    secondLabel = labelList[1];

    // remove additional characters
    QRegularExpression openPar(QRegularExpression::escape("("));
    QRegularExpression closePar(QRegularExpression::escape(")"));

    firstLabel.replace(openPar, "");
    firstLabel.replace(closePar, "");
    secondLabel.replace(openPar, "");
    secondLabel.replace(closePar, "");

    // equivalent shots in each pattern part
    patternShots.first = firstLabel.split("|");
    patternShots.second = secondLabel.split("|");

    // looping over pattern utterances
    QList<QPair<int, qreal>> utterances = it.value();

    for (int i(0); i < utterances.size(); i++) {

      int uttIdx = utterances[i].first;

      // adjusting utterance boundaries to shot pattern ones
      QPair<qint64, qint64> pair = adjustSubBoundaries(subBound[uttIdx].first, subBound[uttIdx].second, shotPattBound);
      uttStart = static_cast<qreal>(pair.first) / 1000.0;
      uttEnd = static_cast<qreal>(pair.second) / 1000.0;

      // labelling current utterance according to the corresponding shot
      bool found(false);

      int j(0);

      while (j < patternShots.first.size() && !found) {
	if (shotUtterances[patternShots.first[j]].contains(utterances[i])) {
	  currSpk = patternLabel + "_S0";
	  found = true;
	}
	j++;
      }

      j = 0;
      while (j < patternShots.second.size() && !found) {
	if (shotUtterances[patternShots.second[j]].contains(utterances[i])) {
	  currSpk = patternLabel + "_S1";
	  found = true;
	}
	j++;
      }
	
      lblOut << uttStart << " " << uttEnd << " " << currSpk << endl;

      emit setSpeaker(static_cast<qint64>(uttStart * 1000),
		      static_cast<qint64>(uttEnd * 1000),
		      currSpk,
		      VideoFrame::Hyp1);
    }

    it++;
  }

  // converting hypotheses .lbl file into .rttm one
  program = "perl";
  arguments << workPath + "scripts/SpkMoulinette.pl" << workPath + "lblLocalSegmentation/" + m_baseName + ".lbl" << workPath + "rttmTmp/" + m_baseName + ".rttm";
  process.start(program, arguments);
  process.waitForFinished();
  arguments.clear();

  // evaluating hypotheses
  program = "perl ";
  args = workPath + "scripts/md-eval-v21.pl" + " -af -m -1 -c 0.25 -r " + workPath + "data/ref/seg/" + m_baseName + ".rttm" + " -s " + workPath + "rttmTmp/" + m_baseName + ".rttm" + " -u " + workPath + "data/ref/local/" + m_baseName + ".uem > " + workPath + "score/local/" + m_baseName + ".nistres";
  out = std::system(qPrintable(program + args));
  
  return true;
}

QVector<cv::Mat> MovieAnalyzer::splitImage(const Mat &frame, int nVBlock, int nHBlock)
{
  QVector<Mat> blocks;
  int blockVSize(frame.rows / nVBlock);
  int blockHSize(frame.cols / nHBlock);
  int width(0);
  int height(0);

  for (int i(0); i < frame.rows; i += blockVSize) {
    height = (i + blockVSize > frame.rows) ? (frame.rows - i) : blockVSize;
    for (int j(0); j < frame.cols; j += blockHSize) {
      width = (j + blockHSize > frame.cols) ? (frame.cols - j) : blockHSize;
      blocks.push_back(frame(Rect(j, i, width, height)));
    }
  }

  return blocks;
}

qreal MovieAnalyzer::meanDistance(const QVector<qreal> &distance)
{
  qreal sum(0.0);

  for (int i(0); i < distance.size(); i++)
    sum += abs(1 - distance[i]);

  return 1 - sum / distance.size();
}

///////////////////////
// auxiliary methods //
///////////////////////

void MovieAnalyzer::setDiarData(const arma::mat &E, const arma::mat &Sigma, const arma::mat &W)
{
  this->E = E;
  this->Sigma = Sigma;
  this->CovW = W;
}

void MovieAnalyzer::setDiarData(const arma::mat &E, const arma::mat &Sigma, const arma::mat &W, QMap<QString, QList<QPair<qreal, qreal>>> speakers)
{
  setDiarData(E, Sigma, W);
  m_utterances = speakers;

  QMap<QString, QList<QPair<qreal, qreal>>>::const_iterator it = m_utterances.begin();

  m_speakers.clear();
  while (it != m_utterances.end()) {
    m_speakers.push_back(it.key());
    it++;
  }
}

void MovieAnalyzer::normalize(UtteranceTree::DistType dist)
{
  qreal normFac;

  for (arma::uword i(0); i < E.n_rows; i++) {

    switch (dist) {

    case UtteranceTree::L2:
      normFac = arma::as_scalar(E.row(i) * E.row(i).t());
      break;

    case UtteranceTree::Mahal:
      normFac = arma::as_scalar(E.row(i) * CovInv * E.row(i).t());
      break;
    }

    E.row(i) = E.row(i) / normFac;
  }
}

QPair<qint64, qint64> MovieAnalyzer::adjustSubBoundaries(qint64 subStart, qint64 subEnd, QList<QPair<qint64, qint64>> shotPattBound)
{
  bool found(false);
  int i(0);

  while (i < shotPattBound.size() && !found) {

    // truncate utterance at the beginning
    if (subStart < shotPattBound[i].first && subEnd > shotPattBound[i].first) {
      subStart = shotPattBound[i].first;
      found = true;
    }

    // utterance included in shot
    else if (subStart >= shotPattBound[i].first && subEnd <= shotPattBound[i].second)
      found = true;

    // truncate utterance at the end
    else if (subStart < shotPattBound[i].second && subEnd > shotPattBound[i].second) {
      subEnd = shotPattBound[i].second;
      found = true;
    }
    i++;
  }

  return QPair<qint64, qint64>(subStart, subEnd);
}

///////////
// slots //
///////////

void MovieAnalyzer::setSpeakerPartition(QList<QList<int>> partition)
{
  QString speaker;
  QList<QPair<qreal, qreal>> utterances;
  QString workPath("spkDiarization/");
  QProcess process;
  QString program;
  QStringList arguments;
  QString args;
  int out;
  
  QString fName = workPath + "lblGlobalSegmentation/" + m_baseName;

  QFile lblFile(fName + ".lbl");

  if (!lblFile.open(QIODevice::WriteOnly | QIODevice::Text))
    return;

  QTextStream lblOut(&lblFile);

  // looping over the partition elements
  for (int i(0); i < partition.size(); i++) {
    QList<int> part = partition[i];

    // looping over each part
    for (int j(0); j < part.size(); j++) {
      speaker = m_speakers[part[j]];
      utterances = m_utterances[speaker];

      // looping over the utterances of each speaker
      for (int k(0); k < utterances.size(); k++) {
	lblOut << utterances[k].first << " " << utterances[k].second << " " << ("S" + QString::number(i)) << endl;
	emit setSpeaker(static_cast<qint64>(utterances[k].first * 1000),
			static_cast<qint64>(utterances[k].second * 1000),
			"S" + QString::number(i),
			VideoFrame::Hyp1);
      }
    }
  }

  // converting hypotheses .lbl file into .rttm one
  program = "perl";
  arguments << workPath + "scripts/SpkMoulinette.pl" << workPath + "lblGlobalSegmentation/" + m_baseName + ".lbl" << workPath + "rttmTmp/" + m_baseName + ".rttm";
  process.start(program, arguments);
  process.waitForFinished();
  arguments.clear();

  // evaluating hypotheses
  program = "perl ";
  args = workPath + "scripts/md-eval-v21.pl" + " -af -m -1 -c 0.25 -r " + workPath + "data/ref/local/" + m_baseName + ".rttm" + " -s " + workPath + "rttmTmp/" + m_baseName + ".rttm" + " -u " + workPath + "data/ref/local/" + m_baseName + ".uem > " + workPath + "score/global/" + m_baseName + ".nistres";
  out = std::system(qPrintable(program + args));

  // retrieving local and global DER
  emit setLocalDer(retrieveDer(workPath + "score/local/" + m_baseName + ".nistres"));
  emit setGlobalDer(retrieveDer(workPath + "score/global/" + m_baseName + ".nistres"));

  // removing files
  QFile::remove(workPath + "lblLocalSegmentation/" + m_baseName + ".lbl");
  QFile::remove(workPath + "lblGlobalSegmentation/" + m_baseName + ".lbl");
  QFile::remove(workPath + "rttmTmp/" + m_baseName + ".rttm");
}

void MovieAnalyzer::playSpeakers(QList<int> speakers)
{
  QList<QPair<qreal, qreal>> utterances;
  QList<QPair<qint64, qint64>> segments;
  QString speaker;

  for (int i(0); i < speakers.size(); i++) {
    speaker = m_speakers[speakers[i]];
    utterances = m_utterances[speaker];
     
    for (int j(0); j < utterances.size(); j++)
      segments.push_back(QPair<qint64, qint64>(utterances[j].first * 1000, utterances[j].second * 1000));
  }
  
  emit playSegments(segments);
}

QString MovieAnalyzer::retrieveDer(const QString fName)
{
  QRegularExpression score("OVERALL SPEAKER DIARIZATION ERROR = (\\d{2}.\\d{2})");
  QFile file(fName);

  if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    return "00.00";

  QTextStream in(&file);

  // parsing score file
  while (!in.atEnd()) {
    QString line = in.readLine();
    QRegularExpressionMatch match = score.match(line);
    
    if (match.hasMatch())
      return match.captured(1);
  }

  return "00.00";
}