/**
  * @RDE_HEADER@
  * Video download communication
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Astrid Müller, SGAS, 2018-02-22
  */

#include "vd_comm.h"
#include "av_helper.h"
#include <AudioVideoManagement/logger.h>
#include <QString>
#include <QStringList>
#include <QByteArray>
#include <QList>
#include <QTextStream>
#include <cmath>

namespace AudioVideoManagement
{

VdComm::VdComm(const QString &vdHost, quint16 vdPort)
  : m_avSocket(vdHost, vdPort, getLogger("VdComm"), getLogger("VdComm.IO"))
  , m_logger(getLogger("VdComm"))
  , m_loggerIO(getLogger("VdComm.IO"))
{
  connect(&m_avSocket, &AVSocketWrapper::readyRead, this, &VdComm::onReadyRead);
  connect(&m_avSocket, &AVSocketWrapper::disconnected, this, &VdComm::disconnected); // signal -> signal
}

void VdComm::start()
{
  m_avSocket.connectToAVS();
}

void VdComm::forceDisconnect()
{
  m_avSocket.disconnectFromHost();
}

void VdComm::switchContext(int exerciseId)
{
  m_avSocket.send(QByteArray("switchContext ex_").append(QByteArray::number(exerciseId)));
}

void VdComm::vdSetScript(const QString &scriptName, AvaStreamType typ, int fileSplitting, const QVector<AvaScriptEntry> &streams,
                         const QString &exportedDirBaseName, const QString &absolutePath)
{
  QStringList streamList;
  streamList.reserve(streams.size());
  for (const auto &stream : streams)
  {
    // not in db here!
    const double vol = pow(10.0, double(stream.db) / 20.0);
    streamList += QStringLiteral("{%1} %2 %3 %4 %5 %6 %7")
        .arg(stream.name,
             QString::number(stream.speed),
             QString::number(stream.mute),
             toString(stream.start),
             toString(stream.stop),
             QString::number(stream.pint),
             QString::number(vol));
  }

  static const QString   cmd = QStringLiteral(R"(VDSetScript "%1" %2 %3 "%4" "%5" "%6")");
  TRACE_LOG(m_loggerIO) << "New Export Script: '" << cmd << "'";
  TRACE_LOG(m_logger) << "New Export Script: '" << cmd << "'";

  m_avSocket.send(cmd.arg(scriptName).arg(static_cast<int>(typ)).arg(QString::number(fileSplitting), streamList.join(QLatin1Char('\n')),
                                                                     exportedDirBaseName, absolutePath).toUtf8());
}

void VdComm::vdReleaseScript(const QString &scriptName)
{
  static const QString   cmd = QStringLiteral(R"(VDReleaseScript "%1")");
  m_avSocket.send(cmd.arg(scriptName).toUtf8());
}

void VdComm::keepAlive()
{
  static const QString   cmd = QStringLiteral("KeepAlive");
  m_avSocket.send(cmd.toUtf8());
}

void VdComm::onReadyRead(QTcpSocket *socket)
{
  Q_ASSERT(socket);
  while (socket->canReadLine())
    parseResponse(socket->readLine().trimmed());
}

void VdComm::parseResponse(const QByteArray &line)
{
  static const QByteArray   GREETER("RCP_VD/1.0");

  DEBUG_LOG(m_loggerIO) << "From A/V: '" << line << "'";

  if (line == GREETER)
  {
    emit connected();
    return;
  }

  const auto parts = AVSocket::parseLine(line);

  bool       couldConvert = false;
  Response   response = static_cast<Response>(parts.at(0).toInt(&couldConvert));
  Q_ASSERT(couldConvert);

  switch (response)
  {
  case Response::Ok:
    Q_ASSERT(parts.size() == 2);
    emit ok();
    break;

  case Response::ExportProgress:
  {
    Q_ASSERT(parts.size() == 3);
    int progress = parts.at(1).toInt();
    emit scriptExportProgress(progress);
    break;
  }
  case Response::ScriptState:
  {
    Q_ASSERT(parts.size() == 5);

    QString          scriptName = QString::fromUtf8(parts.at(1));
    AvaStreamState   scriptState = static_cast<AvaStreamState>(parts.at(3).toInt(&couldConvert));
    Q_ASSERT(couldConvert);
    emit scriptStateReceived(scriptName, scriptState);
    break;
  }

  case Response::KeepAlive:
    emit keepAliveReceived();
    break;

  default:
    DEBUG_LOG(m_logger) << "Response not implemented: " << line;
  }
}

} // namespace AudioVideoManagement