#pragma once
#include "adminive/collection.hpp"
#include "adminive/http.hpp"
#include <drogon/drogon.h>
#include <charconv>
#include <cstdint>
#include <functional>
#include <memory>
#include <shared_mutex>
#include <string>
#include <utility>
#include <vector>
namespace adminive {
template <Json_Type Json>
drogon::HttpResponsePtr make_drogon_response(Http_Response<Json> value) {
    auto response = drogon::HttpResponse::newHttpResponse();
    response->setStatusCode(static_cast<drogon::HttpStatusCode>(value.status));
    response->setContentTypeCode(drogon::CT_APPLICATION_JSON);
    response->setBody(dump_json(value.body, 2));
    return response;
}
using Drogon_Executor = std::function<void(std::function<void()>)>;
using Drogon_Request_Context_Factory = std::function<Request_Context(const drogon::HttpRequestPtr&)>;
struct Drogon_Bind_Options {
    Drogon_Executor executor;
    Drogon_Request_Context_Factory context_factory;
    std::vector<std::string> filters;
};
inline Request_Context make_drogon_request_context(const drogon::HttpRequestPtr& request, const Drogon_Request_Context_Factory& factory) {
    return factory ? factory(request) : Request_Context{};
}
inline std::vector<drogon::internal::HttpConstraint> make_drogon_constraints(drogon::HttpMethod method, const std::vector<std::string>& filters) {
    std::vector<drogon::internal::HttpConstraint> result;
    result.reserve(filters.size() + 1);
    result.emplace_back(method);
    for(const auto& filter : filters) {
        result.emplace_back(filter);
    }
    return result;
}
inline std::size_t read_drogon_size_parameter(const drogon::HttpRequestPtr& request, const char* name, std::size_t fallback) {
    const std::string& text = request->getParameter(name);
    if(text.empty()) {
        return fallback;
    }
    std::size_t value{};
    const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value);
    return error == std::errc{} && end == text.data() + text.size() && value != 0 ? value : fallback;
}
template <Json_Type Json, class Function>
void complete_drogon_request(std::function<void(const drogon::HttpResponsePtr&)>& callback, Function&& function) noexcept {
    try {
        callback(make_drogon_response(std::forward<Function>(function)()));
    } catch(const std::exception& error) {
        callback(make_drogon_response(make_http_error<Json>(500, error.what())));
    } catch(...) {
        callback(make_drogon_response(make_http_error<Json>(500, "unknown server error")));
    }
}
template <Json_Type Json, class Function>
void schedule_drogon_request(const Drogon_Executor& executor, std::function<void(const drogon::HttpResponsePtr&)>&& callback, Function&& function) noexcept {
    auto response_callback = std::make_shared<std::function<void(const drogon::HttpResponsePtr&)>>(std::move(callback));
    std::function<void()> task = [response_callback, function = std::forward<Function>(function)]() mutable {
        complete_drogon_request<Json>(*response_callback, std::move(function));
    };
    try {
        if(executor) {
            executor(task);
        } else {
            task();
        }
    } catch(const std::exception& error) {
        (*response_callback)(make_drogon_response(make_http_error<Json>(500, error.what())));
    } catch(...) {
        (*response_callback)(make_drogon_response(make_http_error<Json>(500, "failed to schedule request")));
    }
}
template <class T, Json_Type Json, Basic_Lock Lock = std::shared_mutex>
requires Writable_Adapted_Object<T> && std::copy_constructible<Object_Model_Type<T>>
class Drogon_Resource {
public:
    using Service = Resource_Service<T, Json, Lock>;
    using Transaction = typename Service::Transaction;
    Drogon_Resource(T& value, std::string path, Transaction transaction = {}, Lock* shared_lock = nullptr) : service_(std::make_shared<Service>(value, std::move(path), std::move(transaction), shared_lock)) {}
    template <Basic_Lock Field_Lock>
    explicit Drogon_Resource(Synchronized_Value<std::remove_cvref_t<T>, Lock, Field_Lock>& value, std::string path, Transaction transaction = {}) : service_(std::make_shared<Service>(value, std::move(path), std::move(transaction))) {}
    template <class Root, Basic_Lock Field_Lock, auto... Members>
    requires (!std::is_const_v<Root>) && std::same_as<typename Synchronized_Field<Root, Lock, Field_Lock, Members...>::value_type, std::remove_cvref_t<T>>
    explicit Drogon_Resource(Synchronized_Field<Root, Lock, Field_Lock, Members...> value, std::string path, Transaction transaction = {}, Resource_Lock_Scope lock_scope = Resource_Lock_Scope::local) : service_(std::make_shared<Service>(value, std::move(path), std::move(transaction), lock_scope)) {}
    Json amis_schema() const {
        return service_->amis_schema();
    }
    void bind(drogon::HttpAppFramework& app, Drogon_Bind_Options options = {}) const {
        const auto service = service_;
        const auto get_constraints = make_drogon_constraints(drogon::Get, options.filters);
        const auto post_constraints = make_drogon_constraints(drogon::Post, options.filters);
        app.registerHandler(service->path() + "/descriptor", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [service] {
                return service->descriptor_response();
            });
        }, get_constraints);
        app.registerHandler(service->path() + "/data", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [service] {
                return service->data_response();
            });
        }, get_constraints);
        app.registerHandler(service->path() + "/amis", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [service] {
                return service->amis_response();
            });
        }, get_constraints);
        app.registerHandler(service->path() + "/data", [service, options](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            Request_Context context;
            try {
                context = make_drogon_request_context(request, options.context_factory);
            } catch(const std::exception& error) {
                callback(make_drogon_response(make_http_error<Json>(500, error.what())));
                return;
            }
            schedule_drogon_request<Json>(options.executor, std::move(callback), [service, body = std::string(request->getBody()), context] {
                return service->update_response(body, context);
            });
        }, post_constraints);
    }
private:
    std::shared_ptr<Service> service_;
};
template <Described_Type T, Json_Type Json, Basic_Lock Lock = std::mutex>
requires std::default_initializable<T> && std::copy_constructible<T> && std::assignable_from<T&, T>
class Drogon_Collection_Resource {
public:
    using Service = Collection_Service<T, Json, Lock>;
    explicit Drogon_Collection_Resource(std::string path, std::vector<T> initial = {}) : service_(std::make_shared<Service>(std::move(path), std::move(initial))) {}
    template <Described_Type Status>
    void register_overview_status(std::string api, std::uint64_t interval = 2000) {
        service_->template register_overview_status<Status>(std::move(api), interval);
    }
    template <auto Function>
    void register_status(std::uint64_t interval = 2000) {
        service_->template register_status<Function>(interval);
    }
    std::size_t size() const {
        return service_->size();
    }
    Json items_json() const {
        return service_->items_json();
    }
    Json amis_schema() const {
        return service_->amis_schema();
    }
    void bind(drogon::HttpAppFramework& app, Drogon_Bind_Options options = {}) const {
        const auto service = service_;
        const auto get_constraints = make_drogon_constraints(drogon::Get, options.filters);
        const auto post_constraints = make_drogon_constraints(drogon::Post, options.filters);
        const auto put_constraints = make_drogon_constraints(drogon::Put, options.filters);
        const auto patch_constraints = make_drogon_constraints(drogon::Patch, options.filters);
        const auto delete_constraints = make_drogon_constraints(drogon::Delete, options.filters);
        app.registerHandler(service->path() + "/descriptor", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [service] {
                return service->descriptor_response();
            });
        }, get_constraints);
        app.registerHandler(service->path() + "/amis", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [service] {
                return service->amis_response();
            });
        }, get_constraints);
        if(service->has_status()) {
            app.registerHandler(service->path() + "/status/descriptor", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
                complete_drogon_request<Json>(callback, [service] {
                    return service->status_descriptor_response();
                });
            }, get_constraints);
            app.registerHandler(service->path() + "/{1:id}/status", [service, options](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
                schedule_drogon_request<Json>(options.executor, std::move(callback), [service, id] {
                    return service->status_response(id);
                });
            }, get_constraints);
        }
        app.registerHandler(service->path(), [service](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            Collection_Query query;
            query.page = read_drogon_size_parameter(request, "page", 1);
            query.per_page = read_drogon_size_parameter(request, "perPage", 20);
            query.order_by = request->getParameter("orderBy");
            query.order_dir = request->getParameter("orderDir");
            complete_drogon_request<Json>(callback, [service, query = std::move(query)]() mutable {
                return service->list_response(std::move(query));
            });
        }, get_constraints);
        app.registerHandler(service->path() + "/{1:id}", [service](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
            complete_drogon_request<Json>(callback, [service, id] {
                return service->item_response(id);
            });
        }, get_constraints);
        app.registerHandler(service->path(), [service, options](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            schedule_drogon_request<Json>(options.executor, std::move(callback), [service, body = std::string(request->getBody())] {
                return service->create_response(body);
            });
        }, post_constraints);
        if(service->user_reorderable()) {
            app.registerHandler(service->path() + "/order", [service, options](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
                schedule_drogon_request<Json>(options.executor, std::move(callback), [service, body = std::string(request->getBody())] {
                    return service->reorder_response(body);
                });
            }, post_constraints);
        }
        const auto bind_update = [service, options](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
            schedule_drogon_request<Json>(options.executor, std::move(callback), [service, id, body = std::string(request->getBody())] {
                return service->update_response(id, body);
            });
        };
        app.registerHandler(service->path() + "/{1:id}", bind_update, put_constraints);
        app.registerHandler(service->path() + "/{1:id}", bind_update, patch_constraints);
        app.registerHandler(service->path() + "/{1:id}", [service, options](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
            schedule_drogon_request<Json>(options.executor, std::move(callback), [service, id] {
                return service->delete_response(id);
            });
        }, delete_constraints);
    }
private:
    std::shared_ptr<Service> service_;
};

template <Described_Type Status, Json_Type Json>
class Drogon_Status_Resource {
public:
    using Reader = std::function<Status(const Request_Context&)>;
    Drogon_Status_Resource(std::string path, Reader reader, std::uint64_t interval = 2000) : state_(std::make_shared<State>(State{std::move(path), std::move(reader), interval, to_status_descriptor_json<Json, Status>()})) {}
    Json amis_schema() const {
        return make_amis_status_service<Json>(state_->descriptor, state_->path + "/data", state_->interval);
    }
    void bind(drogon::HttpAppFramework& app, Drogon_Bind_Options options = {}) const {
        const auto state = state_;
        const auto constraints = make_drogon_constraints(drogon::Get, options.filters);
        app.registerHandler(state->path + "/descriptor", [state](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [state] {
                return make_http_success<Json>(state->descriptor);
            });
        }, constraints);
        app.registerHandler(state->path + "/amis", [state](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            complete_drogon_request<Json>(callback, [state] {
                return make_http_success<Json>(make_amis_status_service<Json>(state->descriptor, state->path + "/data", state->interval));
            });
        }, constraints);
        app.registerHandler(state->path + "/data", [state, options](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
            Request_Context context;
            try {
                context = make_drogon_request_context(request, options.context_factory);
            } catch(const std::exception& error) {
                callback(make_drogon_response(make_http_error<Json>(500, error.what())));
                return;
            }
            schedule_drogon_request<Json>(options.executor, std::move(callback), [state, context] {
                return make_http_success<Json>(to_status_json<Json>(state->reader(context)));
            });
        }, constraints);
    }
private:
    struct State {
        std::string path;
        Reader reader;
        std::uint64_t interval;
        Json descriptor;
    };
    std::shared_ptr<State> state_;
};
}