//
//  ExternalResource.h
//
//  Created by Dale Glass on 6 Sep 2020
//  Copyright 2020 Vircadia contributors.
//
//  Flexible management for external resources (e.g., on S3).
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html

#include "ExternalResource.h"
#include <QDebug>
#include <QLoggingCategory>

Q_LOGGING_CATEGORY(external_resource, "overte.networking.external_resource")

ExternalResource::ExternalResource(QObject* parent) : QObject(parent) {
}

ExternalResource* ExternalResource::getInstance() {
    static ExternalResource instance;
    return &instance;
}

QUrl ExternalResource::getQUrl(Bucket bucket, QString path) {
    qCDebug(external_resource) << "Requested URL for bucket " << bucket << ", path " << path;

    // Whitespace could interfere with the next step
    path = path.trimmed();

    // Remove all initial slashes. This is because if QUrl is fed //foo/bar,
    // it will treat //foo as a domain name. This also ensures the URL is always treated as
    // relative to any path specified in the bucket.
    while (path.startsWith('/')) {
        path = path.remove(0, 1);
    }

    // De-duplicate URL separators, since S3 doesn't actually have subdirectories, and treats a '/' as a part
    // of the filename. This means that "/dir/file.txt" and "/dir//file.txt" are not equivalent on S3.
    //
    // We feed it through a QUrl to ensure we're only working on the path component.
    QUrl pathQUrl(path);

    QString tempPath = pathQUrl.path();
    while (tempPath.contains("//")) {
        tempPath = tempPath.replace("//", "/");
    }
    pathQUrl.setPath(tempPath);

    if (!pathQUrl.isValid()) {
        qCCritical(external_resource) << "External resource " << pathQUrl << " was requested from bucket " << bucket
                                      << " with an invalid path. Error: " << pathQUrl.errorString();
        return QUrl();
    }

    if (!pathQUrl.isRelative()) {
        qCWarning(external_resource) << "External resource " << pathQUrl << " was requested from bucket " << bucket
                                     << " without using a relative path, returning as-is.";
        return pathQUrl;
    }

    QUrl base;
    {
        std::lock_guard<std::mutex> guard(_bucketMutex);

        if (!_bucketBases.contains(bucket)) {
            qCCritical(external_resource) << "External resource " << path << " was requested from unrecognized bucket "
                                          << bucket;
            return QUrl();
        }

        base = _bucketBases[bucket];
    }

    QUrl merged = base.resolved(pathQUrl).adjusted(QUrl::NormalizePathSegments);

    if (merged.isValid()) {
        qCDebug(external_resource) << "External resource resolved to " << merged;
    } else {
        qCCritical(external_resource) << "External resource resolved to invalid URL " << merged << "; Error "
                                      << merged.errorString() << "; base = " << base << "; path = " << path
                                      << "; filtered path = " << pathQUrl;
    }

    return merged;
}

QString ExternalResource::getBase(Bucket bucket) {
    std::lock_guard<std::mutex> guard(_bucketMutex);
    return _bucketBases.value(bucket).toString();
};

bool ExternalResource::setBase(Bucket bucket, const QString& url) {
    QUrl newURL(url);

    if (!newURL.isValid() || newURL.isRelative()) {
        qCCritical(external_resource) << "Attempted to set bucket " << bucket << " to invalid URL " << url;
        return false;
    }

    if (!_bucketBases.contains(bucket)) {
        qCritical(external_resource) << "Invalid bucket " << bucket;
        return false;
    }

    qCDebug(external_resource) << "Setting base URL for " << bucket << " to " << newURL;

    std::lock_guard<std::mutex> guard(_bucketMutex);
    _bucketBases[bucket] = newURL;
    return true;
}