/**
  * @RDE_HEADER@
  * AV helper functions
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Fröbel, SLSE, 2017-06-23
  */

#include "av_helper.h"
#include <QByteArray>
#include <QRegularExpression>

namespace AudioVideoManagement
{

AvaDuration createDuration(const QByteArray &avDuration)
{
  int   i = avDuration.indexOf('.');

  if (i == -1)
  {
    bool         couldConvert = false;
    quint64      seconds = avDuration.toULong(&couldConvert);
    Q_ASSERT(couldConvert);
    return AvaDuration(seconds * 100);
  }
  else
  {
    Q_ASSERT(i + 1 < avDuration.size());

    QByteArray   secondsAsString = avDuration.left(i);
    QByteArray   hsAsString = avDuration.mid(i + 1);
    Q_ASSERT(hsAsString.size() == 2);

    bool       couldConvert = false;
    quint64    seconds = secondsAsString.toULong(&couldConvert);
    Q_ASSERT(couldConvert);

    quint64   hs = hsAsString.toUInt(&couldConvert);
    Q_ASSERT(couldConvert);

    return AvaDuration(seconds * 100 + hs);
  }
}

AvaTimePoint createTimePoint(const QByteArray &avTimePoint)
{
  return AvaTimePoint(createDuration(avTimePoint));
}

QString toString(AvaDuration pos)
{
  std::chrono::seconds   secs = std::chrono::duration_cast<std::chrono::seconds>(pos);
  AvaDuration            rest = pos - secs;

  QString   hsAsString = QString::number(rest.count());
  if (rest.count() < 10)
    hsAsString.prepend(QLatin1Char('0'));

  static const QString   fmt = QStringLiteral("%1.%2");
  return fmt.arg(secs.count()).arg(hsAsString);
}

QString toString(AvaTimePoint pos)
{
  return toString(pos.time_since_epoch());
}

qint64 toMSecSinceEpoch(AvaTimePoint pos)
{
  std::chrono::milliseconds msecs = pos.time_since_epoch();
  return msecs.count();
}

std::pair<AvaStreamSource, QString> extractStreamSource(const QString &nameWithSourceSpec)
{
  if (nameWithSourceSpec.endsWith(QStringLiteral("(S)")))
    return {AvaStreamSource::Server, nameWithSourceSpec.left(nameWithSourceSpec.size() - 3)};
  else if (nameWithSourceSpec.endsWith(QStringLiteral("(L)")))
    return {AvaStreamSource::Local, nameWithSourceSpec.left(nameWithSourceSpec.size() - 3)};
  else
    return {AvaStreamSource::Interface, nameWithSourceSpec};
}

AvaTimePoint toTimePoint(qint64 msecSinceEpoch)
{
  std::chrono::milliseconds   sinceEpochMs{msecSinceEpoch};
  AvaDuration                 sinceEpoch{std::chrono::duration_cast<AvaDuration>(sinceEpochMs)};
  return AvaTimePoint(sinceEpoch);
}

bool isStreamNameValid(const std::string &name)
{
  return isStreamNameValid(QString::fromStdString(name));
}

bool isStreamNameValid(const QString &name)
{
  static const QRegularExpression   regex(QStringLiteral(R"(^\b[\w .-]+\b$)"), QRegularExpression::UseUnicodePropertiesOption);
  return regex.match(name).hasMatch();
}

} // namespace AudioVideoManagement