#include "adminive/adapters/drogon.hpp"
#include "adminive/adapters/nlohmann_json.hpp"
#include <cassert>
#include <functional>
#include <string>
#include <utility>
#include <vector>
namespace drogon_test {
struct Config {
    std::string name{"default"};
};
struct Status {
    std::string user;
};
}
namespace adminive {
template <>
struct Type_Descriptor<drogon_test::Config> {
    static auto get() {
        using T = drogon_test::Config;
        return object<T>("config", "Config", ADMINIVE_FIELD(T, name).editable());
    }
};
template <>
struct Type_Descriptor<drogon_test::Status> {
    static auto get() {
        using T = drogon_test::Status;
        return object<T>("status", "Status", ADMINIVE_FIELD(T, user).label("User"));
    }
};
}
int main() {
    using Json = nlohmann::json;
    drogon_test::Config config;
    drogon::HttpAppFramework app;
    std::vector<std::function<void()>> tasks;
    std::string committed_user;
    adminive::Resource_Transaction<drogon_test::Config> transaction;
    transaction.commit = [&committed_user](const drogon_test::Config&, const adminive::Request_Context& context) {
        committed_user = context.user;
    };
    adminive::Drogon_Bind_Options options;
    options.executor = [&tasks](std::function<void()> task) {
        tasks.push_back(std::move(task));
    };
    options.filters = {"LoginFilter", "AdminFilter"};
    options.context_factory = [](const drogon::HttpRequestPtr& request) {
        adminive::Request_Context context;
        context.user = request->user;
        return context;
    };
    {
        adminive::Drogon_Resource<drogon_test::Config, Json> resource(config, "/config", std::move(transaction));
        resource.bind(app, options);
        adminive::Drogon_Status_Resource<drogon_test::Status, Json> status("/status", [](const adminive::Request_Context& context) {
            if(context.user == "error") {
                throw std::runtime_error("status failed");
            }
            return drogon_test::Status{context.user};
        });
        status.bind(app, options);
    }
    assert(app.filters("/config/data", drogon::Post).size() == 2);
    assert(app.filters("/status/data", drogon::Get).size() == 2);
    auto request = std::make_shared<drogon::HttpRequest>();
    request->body = R"({"name":"updated"})";
    request->user = "wyc";
    drogon::HttpResponsePtr response;
    app.handle("/config/data", drogon::Post, request, [&response](const drogon::HttpResponsePtr& value) {
        response = value;
    });
    assert(!response);
    assert(tasks.size() == 1);
    tasks.front()();
    tasks.erase(tasks.begin());
    assert(response);
    assert(response->status == drogon::k200OK);
    assert(config.name == "updated");
    assert(committed_user == "wyc");
    response.reset();
    app.handle("/status/data", drogon::Get, request, [&response](const drogon::HttpResponsePtr& value) {
        response = value;
    });
    assert(!response);
    assert(tasks.size() == 1);
    tasks.front()();
    tasks.erase(tasks.begin());
    assert(response->status == drogon::k200OK);
    assert(Json::parse(response->body).at("data").at("user").at("value") == "wyc");
    request->user = "error";
    response.reset();
    app.handle("/status/data", drogon::Get, request, [&response](const drogon::HttpResponsePtr& value) {
        response = value;
    });
    tasks.front()();
    tasks.erase(tasks.begin());
    assert(response->status == drogon::k500InternalServerError);
    response.reset();
    app.handle("/status/descriptor", drogon::Get, request, [&response](const drogon::HttpResponsePtr& value) {
        response = value;
    });
    assert(response->status == drogon::k200OK);
    return 0;
}