/*
 *   Copyright (c) Robin E.R. Davies
 *   All rights reserved.

 *   Permission is hereby granted, free of charge, to any person obtaining a copy
 *   of this software and associated documentation files (the "Software"), to deal
 *   in the Software without restriction, including without limitation the rights
 *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *   copies of the Software, and to permit persons to whom the Software is
 *   furnished to do so, subject to the following conditions:

 *   The above copyright notice and this permission notice shall be included in all
 *   copies or substantial portions of the Software.

 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 *   SOFTWARE.
 */

#include "WebServerMod.hpp"
#include <filesystem>
#include "json_variant.hpp"
#include "ss.hpp"
#include "ModTemplateGenerator.hpp"
#include "HtmlHelper.hpp"
#include "MimeTypes.hpp"

using namespace pipedal;
namespace fs = std::filesystem;

namespace pipedal::impl
{

    class ModWebInterceptImpl : public ModWebIntercept
    {
    private:
        using super = ModWebIntercept;
        using self = ModWebInterceptImpl;

        PiPedalModel *model;

    public:
        ModWebInterceptImpl(PiPedalModel *model)
            : super("/resources"),
              model(model)
        {
        }
        virtual bool wants(const std::string &method, const uri &request_uri) const override;

        virtual void head_response(
            const uri &request_uri,
            HttpRequest &req,
            HttpResponse &res,
            std::error_code &ec) override;

        virtual void get_response(
            const uri &request_uri,
            HttpRequest &req,
            HttpResponse &res,
            std::error_code &ec) override;

    private:
        std::string GenerateTemplate(
            const fs::path &templateFile,
            std::shared_ptr<Lv2PluginInfo> pluginInfo);
    };
}

using namespace pipedal::impl;

ModWebIntercept::ptr ModWebIntercept::Create(PiPedalModel *model)
{
    return std::make_shared<impl::ModWebInterceptImpl>(model);
}

bool ModWebInterceptImpl::wants(const std::string &method, const uri &request_uri) const
{
    if (request_uri.segment_count() < 2 || request_uri.segment(0) != "resources")
    {
        return false;
    }
    return true;
}

void ModWebInterceptImpl::head_response(
    const uri &request_uri,
    HttpRequest &req,
    HttpResponse &res,
    std::error_code &ec)
{
    get_response(request_uri, req, res, ec);
    res.clearBody();
}

static void setCacheControl(HttpResponse &res, const fs::path &path)
{
    if (fs::exists(path))
    {
        res.set("Cache-Control", "public, max-age=31536000"); // 1 month
        auto lastModified = std::filesystem::last_write_time(path);
        res.set(HttpField::LastModified, HtmlHelper::timeToHttpDate(lastModified));
        // Set ETag for cache validation
        res.set("ETag", pipedal::HtmlHelper::generateEtag(path));
    }
    else
    {
        res.set("Cache-Control", "no-cache, no-store, must-revalidate");
    }
}
void ModWebInterceptImpl::get_response(
    const uri &request_uri,
    HttpRequest &req,
    HttpResponse &res,
    std::error_code &ec)
{
    try
    {
        std::string ns = request_uri.query("ns");
        std::string strVersion = request_uri.query("v");
        (void)strVersion; // this is just cache-busting, so we don't actually use it.

        std::shared_ptr<Lv2PluginInfo> pluginInfo;
        if (!ns.empty())
        {
            pluginInfo = model->GetPluginInfo(ns);
            if (!pluginInfo)
            {
                throw std::runtime_error("Plugin not found.");
            }
        }
        if (!pluginInfo->modGui())
        {
            throw std::runtime_error("Plugin does not have a ModGui.");
        }
        if (request_uri.segment_count() < 2)
        {
            throw std::runtime_error("Invalid request URI.");
        }
        if (request_uri.segment(0) != "resources")
        {
            throw std::runtime_error("Invalid request URI: expected 'resources'.");
        }   
        std::string segment = request_uri.segment(1);
        if (segment == "_")
        {
            segment = request_uri.segment(2);
            if (segment == "iconTemplate")
            {
                res.set("Content-Type", "text/html");
                res.setBody(GenerateTemplate(
                    pluginInfo->modGui()->iconTemplate(),
                    pluginInfo));
                setCacheControl(res, pluginInfo->modGui()->iconTemplate());
            }
            else if (segment == "stylesheet")
            {
                res.set("Content-Type", "text/css");
                res.setBody(GenerateTemplate(
                    pluginInfo->modGui()->stylesheet(),
                    pluginInfo));
                setCacheControl(res, pluginInfo->modGui()->stylesheet());

            }

            else if (segment == "screenshot")
            {
                std::filesystem::path path = pluginInfo->modGui()->screenshot();
                if (!fs::exists(path))
                {
                    ec =  std::make_error_code(std::errc::no_such_file_or_directory);
                    return;
                }
                if (!fs::is_regular_file(path))
                {
                    throw std::runtime_error("Screenshot is not a regular file: " + path.string());
                }

                size_t size = fs::file_size(path);
                std::string mimeType = MimeTypes::instance().MimeTypeFromExtension(path.extension().string());
                if (mimeType.empty())
                {
                    throw std::runtime_error("Unknown file type for screenshot: " + path.string());
                }
                res.setBodyFile(
                    path,
                    false); // delete when done
                res.set("Content-Type", mimeType);
                res.setContentLength(size);
                setCacheControl(res, path);

            }
            else if (segment == "thumbnail")
            {
                std::filesystem::path path = pluginInfo->modGui()->thumbnail();
                if (!fs::exists(path))
                {
                    throw std::runtime_error("Thumbnail not found: " + path.string());
                }
                if (!fs::is_regular_file(path))
                {
                    throw std::runtime_error("Thumbnail is not a regular file: " + path.string());
                }

                size_t size = fs::file_size(path);
                std::string mimeType = MimeTypes::instance().MimeTypeFromExtension(path.extension().string());
                if (mimeType.empty())
                {
                    throw std::runtime_error("Unknown file type for thumbnail: " + path.string());
                }
                res.setBodyFile(
                    path,
                    false); // delete when done
                res.set("Content-Type", mimeType);
                setCacheControl(res, path);
                res.setContentLength(size);
            } else {
                throw std::runtime_error("Unknown resource: _/" + segment);
            }
        }
        else
        {
            // a request for a plugin resource file.
            fs::path resourcefile = pluginInfo->modGui()->resourceDirectory();
            for (size_t i = 1; i < request_uri.segment_count(); ++i)
            {
                resourcefile /= request_uri.segment(i);
            }
            if (!fs::exists(resourcefile) && !fs::is_regular_file(resourcefile))
            {
                ec =  std::make_error_code(std::errc::no_such_file_or_directory);
                return;
            }
            size_t size = fs::file_size(resourcefile);
            std::string mimeType = MimeTypes::instance().MimeTypeFromExtension(resourcefile.extension().string());
            if (mimeType.empty())
            {
                throw std::runtime_error("Unknown file type for resource: " + resourcefile.string());
            }
            res.setBodyFile(
                resourcefile,
                false); // delete when done
            res.set("Content-Type", mimeType);
            Lv2Log::debug(SS("ModWebIntercept: Serving resource file: " << resourcefile.string() << " (" << size << " bytes)"));
            Lv2Log::debug(SS("    url: " << request_uri.str()));
            setCacheControl(res, resourcefile);
            res.setContentLength(size);
        }
    }
    catch (const std::exception &e)
    {
        res.setBody("Error: " + std::string(e.what()));
        ec = boost::system::errc::make_error_code(boost::system::errc::invalid_argument);
        return;
    }
}

static std::string makeCns(const std::string &encodedUri, int64_t instanceId)
{
    std::stringstream ss;
    ss << "_";
    for (char c : encodedUri)
    {
        if (
            (c >= 'a' && c <= 'z') || (c >= 'A' & c <= 'Z') || (c >= '0' && c <= '9'))
        {
            ss << c;
        }
        else
        {
            ss << '_'; // replace non-alphanumeric characters with '_'
        }
    }
    ss << "_";
    if (instanceId < 0)
    {
        ss << "_";
        instanceId = -instanceId;
    }
    ss << instanceId;
    return ss.str();
}

std::string ModWebInterceptImpl::GenerateTemplate(
    const fs::path &templateFile,
    std::shared_ptr<Lv2PluginInfo> pluginInfo)
{
    if (!fs::exists(templateFile))
    {
        throw std::runtime_error("File not found. " + templateFile.string());
    }

    json_variant context = MakeModGuiTemplateData(pluginInfo);
    int64_t version = pluginInfo->minorVersion() * 1000 +
                      pluginInfo->microVersion();

    std::string encodedUri = HtmlHelper::encode_url_segment(pluginInfo->uri(), true);
    std::string ns = SS("?ns=" << encodedUri << "&v=" << version);
    context["_ns"] = ns;

    std::string cns = makeCns(encodedUri, version);
    context["_cns"] = cns;

    return GenerateFromTemplateFile(
        templateFile,
        context);
}