#pragma once

#include <regex>
#include <boost/json.hpp>
#include <mysqlx/xdevapi.h>
#include <mysqlx/common/api.h>
#include <boost/uuid.hpp>

#include "IExecutor.h"
#include "../DAO/IUserDAO.h"
#include "../DAO/IAuthDAO.h"
#include "../helpers/helpers.h"

namespace uad
{
template <class Body, class Allocator, class ResponseType>
class AuthLoginExecutor : public IExecutor<Body, Allocator, ResponseType>
{
  mysqlx::Session& session_;
  std::shared_ptr<IUserDAO> user_dao_;
  std::shared_ptr<IAuthDAO> auth_dao_;

public:
  AuthLoginExecutor(mysqlx::Session& session,
                           std::shared_ptr<IUserDAO> user_dao,
                           std::shared_ptr<IAuthDAO> auth_dao)
    : session_(session), user_dao_(user_dao), auth_dao_(auth_dao)
  {
  }

  boost::beast::http::response<ResponseType> operator ()(
    boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>>&& req
  ) override
  {
    using namespace boost;
    using namespace boost::json;
    using namespace boost::beast;
    using namespace std::string_literals;

    auto body = req.body();
    value req_json;
    value response_body;

    response_body.emplace_object();

    try
    {
      req_json = json::parse(body);

      const std::string login = req_json.as_object().at("login").as_string().c_str();
      const std::string password = req_json.as_object().at("password").as_string().c_str();

      if (login.empty() || password.empty())
      {
        http::response<ResponseType> res{http::status::unprocessable_entity, req.version()};
        response_body.as_object().emplace("Result", "Login or password are empty");

        res.body() = serialize(response_body);
        res.set(http::field::content_type, "application/json");
        res.content_length(res.body().size());

        return res;
      }

      std::optional<User> user = user_dao_->GetByLogin(login);

      if (!user.has_value() || (user.value().GetHashedPassword() != HashPassword(password)))
      {
        http::response<ResponseType> res{http::status::unprocessable_entity, req.version()};
        response_body.as_object().emplace("Result", "Incorrect login or password");

        res.body() = serialize(response_body);
        res.set(http::field::content_type, "application/json");
        res.content_length(res.body().size());

        return res;
      }
      auto token = GenerateUUID();
      auth_dao_->Login(user.value().GetUUID(), token);

      http::response<ResponseType> res{http::status::ok, req.version()};
      response_body.as_object().emplace("token", token);

      res.body() = serialize(response_body);
      res.set(http::field::content_type, "application/json");
      res.content_length(res.body().size());

      return res;
    }
    catch (const system::system_error& err)
    {
      http::response<ResponseType> res{http::status::bad_request, req.version()};
      response_body.as_object().emplace("Result", "cannot deserialize json");

      res.body() = serialize(response_body);
      res.set(http::field::content_type, "application/json");
      res.content_length(res.body().size());

      return res;
    }
  }
};
}