#pragma once

/// @file
/// @brief Error codes returned by the client-server API

#include <optional>

#include <spdlog/common.h>

#include "mtx/errors.hpp"

namespace mtx {
namespace http {

//! Compound type that includes matrix & network related errors.
struct ClientError
{
    //! Matrix client api related error.
    mtx::errors::Error matrix_error;
    //! Error code if a network related error occured.
    int error_code;
    //! Status code of the associated http response.
    int status_code;
    //! Parsing response error.
    std::string parse_error;

    const char *error_code_string() const;
};
} // namespace http
} // namespace mtx

template<>
struct fmt::formatter<mtx::http::ClientError>
{
    // Presentation format: 'f' - fixed, 'e' - exponential.
    bool print_network_error = false;
    bool print_http_error    = false;
    bool print_parser_error  = false;
    bool print_matrix_error  = false;

    // Parses format specifications of the form ['f' | 'e'].
    constexpr auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
    {
        // [ctx.begin(), ctx.end()) is a character range that contains a part of
        // the format string starting from the format specifications to be parsed,
        // e.g. in
        //
        //   fmt::format("{:f} - point of interest", point{1, 2});
        //
        // the range will contain "f} - point of interest". The formatter should
        // parse specifiers until '}' or the end of the range. In this example
        // the formatter should parse the 'f' specifier and return an iterator
        // pointing to '}'.

        // Parse the presentation format and store it in the formatter:
        auto it = ctx.begin(), end = ctx.end();

        while (it != end && *it != '}') {
            auto tmp = *it++;

            switch (tmp) {
            case 'n':
                print_network_error = true;
                break;
            case 'h':
                print_http_error = true;
                break;
            case 'p':
                print_parser_error = true;
                break;
            case 'm':
                print_matrix_error = true;
                break;
            default:
                throw format_error("invalid format specifier for mtx error");
            }
        }

        // Check if reached the end of the range:
        if (it != end && *it != '}')
            throw fmt::format_error("invalid format");

        // Return an iterator past the end of the parsed range:
        return it;
    }

    // Formats the point p using the parsed format specification (presentation)
    // stored in this formatter.
    template<typename FormatContext>
    auto format(const mtx::http::ClientError &e, FormatContext &ctx) const -> decltype(ctx.out())
    {
        // ctx.out() is an output iterator to write to.
        bool prepend_comma = false;
        fmt::format_to(ctx.out(), "(");
        if (print_network_error || e.error_code) {
            fmt::format_to(ctx.out(), "connection: {}", e.error_code_string());
            prepend_comma = true;
        }

        if (print_http_error ||
            (e.status_code != 0 && (e.status_code < 200 || e.status_code >= 300))) {
            if (prepend_comma)
                fmt::format_to(ctx.out(), ", ");
            fmt::format_to(ctx.out(), "http: {}", e.status_code);
            prepend_comma = true;
        }

        if (print_parser_error || !e.parse_error.empty()) {
            if (prepend_comma)
                fmt::format_to(ctx.out(), ", ");
            fmt::format_to(ctx.out(), "parser: {}", e.parse_error);
            prepend_comma = true;
        }

        if (print_parser_error ||
            (e.matrix_error.errcode != mtx::errors::ErrorCode::M_UNRECOGNIZED &&
             !e.matrix_error.error.empty())) {
            if (prepend_comma)
                fmt::format_to(ctx.out(), ", ");
            fmt::format_to(ctx.out(),
                           "matrix: {}:'{}'",
                           to_string(e.matrix_error.errcode),
                           e.matrix_error.error);
        }

        return fmt::format_to(ctx.out(), ")");
    }
};

template<>
struct fmt::formatter<std::optional<mtx::http::ClientError>> : formatter<mtx::http::ClientError>
{
    // parse is inherited from formatter<string_view>.
    template<typename FormatContext>
    auto format(std::optional<mtx::http::ClientError> c, FormatContext &ctx) const
    {
        if (!c)
            return fmt::format_to(ctx.out(), "(no error)");
        else
            return formatter<mtx::http::ClientError>::format(*c, ctx);
    }
};
