#include "core/ConfigStore.h"
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QSaveFile>
#include <QStandardPaths>
#include <algorithm>

namespace whittle {
	namespace {

		QJsonObject readJson(const QString& path) {
			QFile f(path);
			if (!f.open(QIODevice::ReadOnly)) return {};
			const QJsonDocument doc = QJsonDocument::fromJson(f.readAll());
			return doc.isObject() ? doc.object() : QJsonObject{};
		}

		bool writeJson(const QString& path, const QJsonObject& obj) {
			QDir().mkpath(QFileInfo(path).absolutePath());
			QSaveFile f(path);
			if (!f.open(QIODevice::WriteOnly)) return false;
			f.write(QJsonDocument(obj).toJson(QJsonDocument::Indented));
			return f.commit();
		}

		QString settingsPath() { return ConfigStore::configDir() + "/settings.json"; }
		QString schemesPath()  { return ConfigStore::configDir() + "/schemes.json";  }

		constexpr char kSchemes[] = "schemes";

} // namespace

QString ConfigStore::configDir() {
	QString base = QStandardPaths::writableLocation(
		QStandardPaths::GenericConfigLocation);
	if (base.isEmpty()) base = QDir::homePath() + "/.config";
	const QString dir = base + "/whittle";
	QDir().mkpath(dir);
	return dir;
}

FilterSettings ConfigStore::loadFilter() {
	FilterSettings f;
	const QJsonObject o = readJson(settingsPath());
	if (o.isEmpty()) return f;

	f.compareSize = o.value("compareSize").toBool(f.compareSize);
	f.compareTime = o.value("compareTime").toBool(f.compareTime);
	if (!f.compareSize && !f.compareTime) f.compareSize = f.compareTime = true;

	f.toleranceNs = qint64(o.value("toleranceNs").toDouble(double(f.toleranceNs)));
	f.display = (o.value("display").toString() == QLatin1String("all"))
	? FilterSettings::Display::All
	: FilterSettings::Display::OnlyDiff;
	f.recursive      = o.value("recursive").toBool(f.recursive);
	f.loadLastScheme = o.value("loadLastScheme").toBool(f.loadLastScheme);
	return f;
}

bool ConfigStore::saveFilter(const FilterSettings& f) {
	QJsonObject o = readJson(settingsPath());
	o["compareSize"] = f.compareSize;
	o["compareTime"] = f.compareTime;
	o["toleranceNs"] = double(f.toleranceNs);
	o["display"] = (f.display == FilterSettings::Display::All)
	? QStringLiteral("all") : QStringLiteral("diff");
	o["recursive"]      = f.recursive;
	o["loadLastScheme"] = f.loadLastScheme;
	return writeJson(settingsPath(), o);
}

QString ConfigStore::loadLastSchemeName() {
	return readJson(settingsPath()).value("lastScheme").toString();
}

bool ConfigStore::saveLastSchemeName(const QString& name) {
	QJsonObject o = readJson(settingsPath());
	o["lastScheme"] = name;
	return writeJson(settingsPath(), o);
}

QStringList ConfigStore::schemeNames() {
	const QJsonObject all = readJson(schemesPath())
	.value(kSchemes).toObject();
	QStringList names = all.keys();
	std::sort(names.begin(), names.end(), [](const QString& a, const QString& b) {
		return a.compare(b, Qt::CaseInsensitive) < 0;
	});
	return names;
}

bool ConfigStore::hasScheme(const QString& name) {
	return readJson(schemesPath()).value(kSchemes).toObject().contains(name);
}

bool ConfigStore::saveScheme(const QString& name, const Scheme& s) {
	if (name.trimmed().isEmpty()) return false;

	QJsonObject root = readJson(schemesPath());
	QJsonObject all  = root.value(kSchemes).toObject();

	QJsonArray roots;
	for (const QString& r : s.roots) roots.append(r);

		QJsonArray excluded;
	for (const QString& e : s.excluded) excluded.append(e);

		QJsonObject entry;
	entry["recursive"] = s.recursive;
	entry["roots"]     = roots;
	entry["excluded"]  = excluded;

	all[name] = entry;
	root[kSchemes] = all;
	return writeJson(schemesPath(), root);
}

ConfigStore::Scheme ConfigStore::loadScheme(const QString& name, bool* found) {
	Scheme s;
	const QJsonObject all = readJson(schemesPath()).value(kSchemes).toObject();
	const auto it = all.find(name);
	if (it == all.end()) { if (found) *found = false; return s; }

	const QJsonObject entry = it->toObject();
	s.recursive = entry.value("recursive").toBool(true);
	for (const QJsonValue& v : entry.value("roots").toArray()) {
		const QString p = v.toString();
		if (!p.isEmpty()) s.roots << p;
	}
	for (const QJsonValue& v : entry.value("excluded").toArray()) {
		const QString p = v.toString();
		if (!p.isEmpty()) s.excluded << p;
	}
	if (found) *found = true;
	return s;
}

bool ConfigStore::deleteScheme(const QString& name) {
	QJsonObject root = readJson(schemesPath());
	QJsonObject all  = root.value(kSchemes).toObject();
	if (!all.contains(name)) return false;

	all.remove(name);
	root[kSchemes] = all;
	if (!writeJson(schemesPath(), root)) return false;

	if (loadLastSchemeName() == name) saveLastSchemeName(QString());
	return true;
}

}