#pragma once

#include <string>
#include <system_error>
#include <variant>

namespace rublon {

class SocketError {
  public:
    enum ErrorClass { Timeout };

    SocketError() : errorClass{Timeout} {}
    SocketError(ErrorClass e) : errorClass{e} {}
    SocketError(ErrorClass e, std::string r) : errorClass{e}, reson{std::move(r)} {}

    ErrorClass errorClass;
    std::string reson;

    // error_category interface
  public:
    const char * name() const noexcept {
        return "SockerError";
    }
    std::string message(int) const {
        return "";
    }
};

class CoreHandlerError {
  public:
    enum ErrorClass { BadSigature, CoreException, ConnectionError, BrokenData };

    CoreHandlerError(ErrorClass e) : errorClass{e} {}
    CoreHandlerError(ErrorClass e, std::string r) : errorClass{e}, reson{std::move(r)} {}

    ErrorClass errorClass;
    std::string reson;
    const char * name() const noexcept {
        return "CoreHandlerError";
    }
    std::string message(int) const {
        return "";
    }
};

class MethodError {
  public:
    enum ErrorClass { BadMethod };

    MethodError(ErrorClass e) : errorClass{e} {}
    MethodError(ErrorClass e, std::string r) : errorClass{e}, reson{std::move(r)} {}

    ErrorClass errorClass;
    std::string reson;
    const char * name() const noexcept {
        return "MethodError";
    }
    std::string message(int) const {
        return "";
    }
};

class Critical {};

class Error {
    std::variant< std::monostate, CoreHandlerError, SocketError, Critical, MethodError > _error;

    enum class Category { None, CoreHandlerError, SockerError, Criticat, MethodError };

  public:
    Error() = default;

    Error(CoreHandlerError error) : _error{error} {}
    Error(SocketError error) : _error{error} {}
    Error(Critical error) : _error{error} {}
    Error(MethodError error) : _error{error} {}

    Error(const Error &) = default;
    Error(Error &&)      = default;

    Error & operator=(const Error &) = default;
    Error & operator=(Error &&)      = default;

    constexpr bool coreError() const {
        return _error.index() == 1;
    }

    constexpr bool sockerError() const {
        return _error.index() == 2;
    }

    Category category() const noexcept {
        return static_cast< Category >(_error.index());
    }
};

} // namespace rublon