/*
  This program 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
  2 of the License, or (at your option) any later version.
*/

#include <QString>
#include <QByteArray>
#include <QFileInfo>
#include <QFile>
#include <QSettings>
#include <QCryptographicHash>
#include <QHash>
#include <QSettings>
#include <QDir>
#include <QPixmap>
#include <QTemporaryFile>
#include <QProcess>
#include <QRect>
#include <QTime>
#include <QtWidgets/QWidget>
#include <QtWidgets/QDesktopWidget>
#include <QtWidgets/QApplication>

#include <stdio.h>

#include "helper.h"

namespace Helper {
	const QString mimeType(const QString &path){
		QString retval;
		magic_t mc = magic_open(MAGIC_MIME_TYPE);
		QByteArray name = path.toUtf8();
		if(mc){
			magic_load(mc, 0);
			const char* magic_c = magic_file(mc, name.constData());
			retval = QString(magic_c);
			magic_close(mc);
		}
		if(retval.toLower().startsWith("application/octet-stream")){
			magic_t mc = magic_open(MAGIC_NONE);
			if(mc){
				magic_load(mc, 0);
				const char* magic_c = magic_file(mc, name.constData());
				QString desc(magic_c);
				magic_close(mc);
                if(desc.toLower().contains("mpeg sequence") || desc.toLower().contains("microsoft asf") || desc.toLower().contains("matroska")){
					retval = "video/";
				}
			}
		}
		return retval;
	}

	const QString md5Sum(const QString &path){
		QFileInfo info(path);
		if(!info.exists() || !info.isFile()){
			return QString();
		}

		QString retval;
		QCryptographicHash h(QCryptographicHash::Md5);
		QFile file(path);
		file.open(QIODevice::ReadOnly);
		qint64 read = 0;
		if(info.size() < (5 * 1024 * 1024)){
			QByteArray data(4096, '\0');
			do {
				read = file.read(data.data(), 4096);
                if(read > 0){
                    h.addData(data.data(), read);
                }
			} while (read == 4096);
			QByteArray res = h.result();
			retval = res.toHex().toLower();
		}else{
			QByteArray data(512, '\0');
			int offset = info.size() / 3;
			file.seek(offset);
			int numBytes = 512 * 1024;
			int readBytes = 0;
			do {
				read = file.read(data.data(), 512);
                if(read > 0){
                    readBytes += read;
                }else{
                    return QString();
                }
				h.addData(data.data(), read);
			} while(readBytes < numBytes);
			QByteArray res = h.result();
			retval = res.toHex().toLower();
		}
		return retval;
	}

    const QString moveToArchive(const QString &path, const QString &md5, bool copy){
		QFileInfo info(path);
		if(!info.exists()){
			return QString();
		}
		QFileInfo destFile = QFileInfo(createArchivePath(path, md5));
		if(destFile.exists()){
			destFile = QFileInfo(createArchivePath(path, md5, true));
			if(destFile.exists()){
				return QString();
			}
		}
		QFileInfo destDir = QFileInfo(destFile.absolutePath());
		if(!destDir.exists()){
			QDir::root().mkpath(destFile.absolutePath());
		}
        bool success = false;
        if(copy){
            success = QFile::copy(path, destFile.absoluteFilePath());
        }else{
            success = QFile::rename(path, destFile.absoluteFilePath());
        }
		if(success){
			return destFile.absoluteFilePath();
		}
		return QString();
	}

	bool removeFromArchive(const QString &fileName, const QString &md5){
		QString file = createArchivePath(fileName, md5);
		QFileInfo info(file);
		if(!info.exists()){
			return false;
		}
		return QFile::remove(file);
	}

	const QString createArchivePath(const QString &path, const QString &md5, bool withMd5){
		QSettings s;
		QString archiveDir = s.value("paths/archivedir").toString();
		QFileInfo info(path);
		QString retval;
		if(withMd5){
			retval = QString("%1/%2/%3/%4_%5.%6").arg(archiveDir).arg(md5[0]).arg(md5[1]).arg(info.completeBaseName()).arg(md5).arg(info.suffix());
		}else{
			retval = QString("%1/%2/%3/%4").arg(archiveDir).arg(md5[0]).arg(md5[1]).arg(info.fileName());
		}
		return retval;
	}

	QPair<QString, QStringList> programData(const QString &prefix, const QString &preferred){
		QSettings s;
		QString section = QString("programs_%1").arg(prefix);
		QHash<QString, QVariant> data = s.value(QString("%1/data").arg(section)).toHash();
		if(data.isEmpty()){
			return QPair<QString, QStringList>();
		}
		QHash<QString, QVariant> programData;
		if(!preferred.isEmpty()){
			if(data.keys().contains(preferred)){
				programData = data.value(preferred).toHash();
				return qMakePair(programData.value("path").toString(), programData.value("args").toStringList());
			}
			return QPair<QString, QStringList>();
		}
		QString defaultProg = s.value(QString("%1/default").arg(section)).toString();
		if(defaultProg.isEmpty()){
			return QPair<QString, QStringList>();
		}
		programData = data.value(defaultProg).toHash();
		return qMakePair(programData.value("path").toString(), programData.value("args").toStringList());
	}

	const QString durationFromSecs(qint64 secs){
		int minutes = secs / 60;
		int hours = 0;
		int seconds = 0;
		if(minutes > 60){
			hours = minutes / 60;
			minutes -= hours * 60;
		}
		seconds = secs - hours * 60 * 60 - minutes * 60;
		seconds = (seconds > 60) ? 59 : seconds;
		QByteArray retval(10, '\0');
		::snprintf(retval.data(), 9, "%.2d:%.2d:%.2d", hours, minutes, seconds);
		return retval;
	}

	QVariant bytesFromUnit(QVariant number, const QString unit){
		QString u = unit.toLower();
		quint64 retval = number.toULongLong();
		if(u == "k"){
			retval = retval * 1024;
		}else if(u == "m"){
			retval = retval * 1024 * 1024;
		}else if(u == "g"){
			retval = retval * 1024 * 1024 * 1024;
		}
		return retval;
	}

	const QStringList toStringList(const QList<QVariant> &list){
		QStringList retval;
		foreach(QVariant v, list){
			retval << v.toString();
		}
		return retval;
	}

	const QString colorToHtml(const QColor &color){
		char colString[7];
		::snprintf(colString, 7, "%0x%0x%0x", color.red(), color.green(), color.blue());
        return QString::fromLatin1(colString);
	}

	void centerWidget(QWidget *widget){
		QRect widgetRect = widget->rect();
        widgetRect.moveCenter(qApp->desktop()->screenGeometry(widget).center());
		widget->move(widgetRect.topLeft());
	}

    QList<QVariant> duration(const QString &path){
        QSettings s;
        QString ffProbe = s.value("paths/ffprobe").toString();
        QStringList args;
        QList<QVariant> retval = QList<QVariant>() << QVariant() << QVariant();
        args << "-show_streams" << path;
        QProcess ffproc;
        ffproc.start(ffProbe, args);
        if(!ffproc.waitForStarted()){
            return retval;
        }
        ffproc.waitForFinished();
        QByteArray ffData = ffproc.readAllStandardError();
        QList<QByteArray> lines = ffData.split('\n');

        foreach(QString l, lines){
            QString llc = l.toLower();
            if(llc.contains("duration")){
                int idx = llc.indexOf("duration:");
                retval[0].setValue(Duration(llc.mid(idx + 10, 8)));
                idx = llc.indexOf("bitrate:");
                retval[1] = llc.mid(idx + 9);
                break;
            }
        }
        return retval;
    }

    Duration::Duration() : mHours(0), mMinutes(0), mSeconds(0) {}

    Duration::Duration(const QString &dur) : mHours(0), mMinutes(0), mSeconds(0){
        QStringList parts = dur.split(':');
        if(parts.size() == 3){
            mHours = parts.at(0).toInt();
            mMinutes = parts.at(1).toInt();
            mSeconds = parts.at(2).toInt();
        }
    }

    Duration Duration::operator+(const Duration &dur) const{
        Duration retval;
        retval.mSeconds = mSeconds + dur.mSeconds;
        retval.mMinutes = mMinutes + dur.mMinutes + retval.mSeconds / 60;
        retval.mSeconds %= 60;
        retval.mHours = mHours + dur.mHours + retval.mMinutes / 60;
        retval.mMinutes %= 60;
        return retval;
    }

    const QString Duration::toString() const {
        QString retval = QString("%1:%2:%3").arg(QString::number(mHours), 2, '0').arg(QString::number(mMinutes), 2, '0').arg(QString::number(mSeconds), 2, '0');
        return retval;
    }

    bool Duration::isNull() const {
        return mHours == 0 && mMinutes == 0 && mSeconds == 0;
    }

}