//    This file is part of Motion Watch.

//    Motion Watch is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.

//    Motion Watch is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.

#include "common.h"

QString getParam(const QString &key, const QStringList &args)
{
    // this can be used by command objects to pick out parameters
    // from a command line that are pointed by a name identifier
    // example: -i /etc/some_file, this function should pick out
    // "/etc/some_file" from args if "-i" is passed into key.

    QString ret;

    int pos = args.indexOf(QRegularExpression(key, QRegularExpression::CaseInsensitiveOption));

    if (pos != -1)
    {
        // key found.

        if ((pos + 1) <= (args.size() - 1))
        {
            // check ahead to make sure pos + 1 will not go out
            // of range.

            if (!args[pos + 1].startsWith("-"))
            {
                // the "-" used throughout this application
                // indicates an argument so the above 'if'
                // statement will check to make sure it does
                // not return another argument as a parameter
                // in case a back-to-back "-arg -arg" is
                // present.

                ret = args[pos + 1];
            }
        }
    }

    return ret;
}

QStringList lsFilesInDir(const QString &path, const QString &ext)
{
    QStringList filters;

    filters << "*" + ext;

    QDir dirObj(path);

    dirObj.setFilter(QDir::Files);
    dirObj.setNameFilters(filters);
    dirObj.setSorting(QDir::Name);

    return dirObj.entryList();
}

QStringList lsDirsInDir(const QString &path)
{
    QDir dirObj(path);

    dirObj.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
    dirObj.setSorting(QDir::Name);

    return dirObj.entryList();
}

QStringList listFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs, char dir)
{
    QStringList ret;

    for (auto i = 0; i < secs; ++i)
    {
        QString filePath;

        if (dir == '-') filePath = path + "/" + stamp.addSecs(-i).toString(DATETIME_FMT) + ext;
        if (dir == '+') filePath = path + "/" + stamp.addSecs(i).toString(DATETIME_FMT) + ext;

        if (QFile::exists(filePath))
        {
            if (dir == '-') ret.insert(0, filePath);
            if (dir == '+') ret.append(filePath);
        }
    }

    return ret;
}

QStringList backwardFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs)
{
    return listFacingFiles(path, ext, stamp, secs, '-');
}

QStringList forwardFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs)
{
    return listFacingFiles(path, ext, stamp, secs, '+');
}

void enforceMaxEvents(shared_t *share)
{
    auto names = lsFilesInDir(share->recPath, share->recExt);

    while (names.size() > share->maxEvents)
    {
        auto nameOnly = share->recPath + "/" + names[0];

        nameOnly.chop(share->recExt.size());

        auto vidFile = nameOnly + share->recExt;
        auto imgFile = nameOnly + share->thumbExt;

        QFile::remove(vidFile);
        QFile::remove(imgFile);

        names.removeFirst();
    }
}

void enforceMaxImages(shared_t *share)
{
    auto names = lsFilesInDir(share->buffPath + "/img", ".bmp");

    while (names.size() > (share->liveSecs / 2))
    {
        QFile::remove(share->buffPath + "/img/" + names[0]);

        names.removeFirst();
    }
}

void enforceMaxClips(shared_t *share)
{
    auto names = lsFilesInDir(share->buffPath + "/live", share->streamExt);

    while (names.size() > (share->liveSecs / 2))
    {
        QFile::remove(share->buffPath + "/live/" + names[0]);

        names.removeFirst();
    }
}

void rdLine(const QString &param, const QString &line, QString *value)
{
    if (line.startsWith(param))
    {
        *value = line.mid(param.size()).trimmed();
    }
}

void rdLine(const QString &param, const QString &line, int *value)
{
    if (line.startsWith(param))
    {
        *value = line.mid(param.size()).trimmed().toInt();
    }
}

void rdLine(const QString &param, const QString &line, bool *value)
{
    if (line.startsWith(param))
    {
        auto val = line.mid(param.size()).trimmed();
        
        *value = (val == "y" || val == "Y");
    }
}

void extCorrection(QString &ext)
{
    if (!ext.startsWith("."))
    {
        ext = "." + ext;
    }
}

bool mkPath(const QString &path)
{
    auto ret = true;
    
    if (!QDir().exists(path))
    {
        ret = QDir().mkpath(path);
    }
    
    return ret;
}

bool rdConf(const QString &filePath, shared_t *share)
{
    QFile varFile(filePath);

    if (!varFile.open(QFile::ReadOnly))
    {
        share->retCode = ENOENT;

        QTextStream(stderr) << "err: config file - " << filePath << " does not exists or lack read permissions." << Qt::endl;
    }
    else
    {
        share->recordUri.clear();
        share->postCmd.clear();
        share->camName.clear();
        share->buffPath.clear();
        share->recPath.clear();
        share->servGroup.clear();
        
        auto thrCount = QThread::idealThreadCount() / 2;

        share->retCode      = 0;
        share->imgThresh    = 8000;
        share->maxEvents    = 30;
        share->skipCmd      = false;
        share->postSecs     = 60;
        share->evMaxSecs    = 30;
        share->conf         = filePath;
        share->outputType   = "stderr";
        share->compCmd      = "magick compare -metric FUZZ " + QString(PREV_IMG) + " " + QString(NEXT_IMG) + " /dev/null";
        share->streamCodec  = "copy";
        share->streamExt    = ".avi";
        share->recExt       = ".avi";
        share->thumbExt     = ".jpg";
        share->recFps       = 30;
        share->liveSecs     = 80;
        share->recScale     = "1280:720";
        share->imgScale     = "320:240";
        share->servUser     = APP_BIN;

        QString line;

        do
        {
            line = QString::fromUtf8(varFile.readLine());

            if (!line.startsWith("#"))
            {
                rdLine("cam_name = ",       line, &share->camName);
                rdLine("recording_uri = ",  line, &share->recordUri);
                rdLine("buffer_path = ",    line, &share->buffPath);
                rdLine("rec_path = ",       line, &share->recPath);
                rdLine("max_event_secs = ", line, &share->evMaxSecs);
                rdLine("post_secs = ",      line, &share->postSecs);
                rdLine("post_cmd = ",       line, &share->postCmd);
                rdLine("img_thresh = ",     line, &share->imgThresh);
                rdLine("max_events = ",     line, &share->maxEvents);
                rdLine("img_comp_out = ",   line, &share->outputType);
                rdLine("img_comp_cmd = ",   line, &share->compCmd);
                rdLine("stream_codec = ",   line, &share->streamCodec);
                rdLine("stream_ext = ",     line, &share->streamExt);
                rdLine("rec_ext = ",        line, &share->recExt);
                rdLine("thumbnail_ext = ",  line, &share->thumbExt);
                rdLine("rec_fps = ",        line, &share->recFps);
                rdLine("rec_scale = ",      line, &share->recScale);
                rdLine("img_scale = ",      line, &share->imgScale);
                rdLine("service_user = ",   line, &share->servUser);
                rdLine("service_group = ",  line, &share->servGroup);
                rdLine("live_secs = ",      line, &share->liveSecs);
            }

        } while(!line.isEmpty());

        if (share->camName.isEmpty())
        {
            share->camName = QFileInfo(share->conf).baseName();
        }
        
        extCorrection(share->streamExt);
        extCorrection(share->recExt);
        extCorrection(share->thumbExt);

        if (share->outputType != "stdout" && share->outputType != "stderr")
        {
            share->outputType = "stderr";
        }
        
        if (share->buffPath.isEmpty())
        {
            share->buffPath = "/var/buffer/" + share->camName;
        }
        else
        {
            share->buffPath = QDir::cleanPath(share->buffPath);
        }
        
        if (share->recPath.isEmpty())
        {
            share->recPath = "/var/footage/" + share->camName;
        }
        else
        {
            share->recPath = QDir::cleanPath(share->recPath);
        }

        if (share->liveSecs < 10)
        {
            share->liveSecs = 10;
        }

        if ((share->liveSecs - 4) < share->evMaxSecs)
        {
            share->evMaxSecs = share->liveSecs - 4;
        }

        if (share->servGroup.isEmpty())
        {
            share->servGroup = share->servUser;
        }

        share->servMainLoop = QString(APP_BIN) + ".main_loop." + share->camName;
        share->servVidLoop  = QString(APP_BIN) + ".vid_loop."  + share->camName;
    }

    return share->retCode == 0;
}

QString buildThreadCount(int count)
{
    QString ret = "0";
    
    for (auto i = 1; i < count; ++i)
    {
        ret.append(","); ret.append(QString::number(i));
    }
    
    return ret;
}

QStringList parseArgs(const QByteArray &data, int maxArgs, int *pos)
{
    QStringList ret;
    QString     arg;

    auto line      = QString::fromUtf8(data);
    auto inDQuotes = false;
    auto inSQuotes = false;
    auto escaped   = false;

    if (pos != nullptr) *pos = 0;

    for (int i = 0; i < line.size(); ++i)
    {
        if (pos != nullptr) *pos += 1;

        if ((line[i] == '\'') && !inDQuotes && !escaped)
        {
            // single quote '

            inSQuotes = !inSQuotes;
        }
        else if ((line[i] == '\"') && !inSQuotes && !escaped)
        {
            // double quote "

            inDQuotes = !inDQuotes;
        }
        else
        {
            escaped = false;

            if (line[i].isSpace() && !inDQuotes && !inSQuotes)
            {
                // space

                if (!arg.isEmpty())
                {
                    ret.append(arg);
                    arg.clear();
                }
            }
            else
            {
                if ((line[i] == '\\') && ((i + 1) < line.size()))
                {
                    if ((line[i + 1] == '\'') || (line[i + 1] == '\"'))
                    {
                        escaped = true;
                    }
                    else
                    {
                        arg.append(line[i]);
                    }
                }
                else
                {
                    arg.append(line[i]);
                }
            }
        }

        if ((ret.size() >= maxArgs) && (maxArgs != -1))
        {
            break;
        }
    }

    if (!arg.isEmpty() && !inDQuotes && !inSQuotes)
    {
        ret.append(arg);
    }

    return ret;
}