#ifndef UTILS_H
#define UTILS_H

#include <atomic>
#include <iostream>
#include <typeinfo>

#include <QCameraViewfinderSettings>
#include <QDateTime>
#include <QDebug>
#include <QElapsedTimer>
#include <QFile>
#include <QMutex>
#include <QTextStream>

#include <QCameraInfo>
Q_DECLARE_METATYPE(QCameraInfo)

#include <QSettings>
#include <QSoundEffect>
#include <QWidget>

#include "LogWidget.h"

typedef qint64 Timestamp;
extern const Timestamp maxTimestamp;
Q_DECLARE_METATYPE(Timestamp)

// useful common tokens for data
class Token {
public:
    static const char Delimiter;
    static const char Newline;
    static const char JournalEntry;
    static const char HeaderEntry;
    static const char MarkerIdDelimiter;
    static const char MarkerValueDelimiter;
    static const char MarkerEnd;
    static const int Precision;
};

template <typename T>
inline QString journalField(const T& v)
{
    return QString("%1%2").arg(v).arg(Token::Delimiter);
}
template <>
inline QString journalField<double>(const double& v)
{
    return QString("%1%2").arg(v, 0, 'g', Token::Precision).arg(Token::Delimiter);
}
template <>
inline QString journalField<float>(const float& v)
{
    return journalField(static_cast<double>(v));
}

template <typename T>
inline void checkDelimitiers()
{
    int dSize = T().toQString().split(Token::Delimiter).size();
    int hSize = T().header().split(Token::Delimiter).size();
    if (dSize != hSize) {
        QString err = QString("%1: Data delimiters (%2) don't match header delimiters (%3)").arg(typeid(T).name()).arg(dSize).arg(hSize);
        qFatal(err.toStdString().c_str());
    }
}

/*
 * Utility functions
 */

QDebug
operator<<(QDebug dbg, const QCameraViewfinderSettings& p);

void logInitBanner();
void logExitBanner();
void logMessages(QtMsgType type, const QMessageLogContext& context, const QString& msg);

QString toQString(QVideoFrame::PixelFormat format);
QString toQString(QCameraViewfinderSettings setting);

QString iniStr(QString str);

template <typename T>
T ns2ms(const T v) { return 1.0e-6 * v; }

void delay(const int& thMs);

template <typename T>
void set(const QSettings* settings, const QString key, T& v)
{
    if (!settings)
        return;
    QVariant variant = settings->value(key);
    if (variant.isValid())
        v = qvariant_cast<T>(variant);
}

void loadSoundEffect(const QString& fileName, const QString& exeDir, QSoundEffect& effect);

template <typename T>
double median(T v)
{
    std::sort(v.begin(), v.end());
    size_t mid = v.size() / 2;
    return v.size() % 2 == 0 ? (v[mid] + v[mid - 1]) / 2 : v[mid];
}

template <typename T>
double mean(T v)
{
    return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
}

template <typename T>
T normalize(const T value, const T mn, const T mx)
{
    return (value - mn) / (mx - mn);
}

#endif // UTILS_H