#include <netdb.h>
#include <unistd.h>
#include <config.h>
#include <helpers.h>
#include <cmath>
#include <models/controller_dbo.h>
#include <fstream>
#include "api_v1_controllers.h"
using namespace api::v1;

void controllers::post_discover(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
{

    int discover_server_socket = helpers::bind_tcp_server("0.0.0.0", "0", config::discover_max_client_backlog);
    int discover_server_port = helpers::get_server_port(discover_server_socket);

    if(discover_server_port == -1)
    {
        auto resp = HttpResponse::newHttpResponse();
        resp->setStatusCode(k500InternalServerError);
        callback(resp);
        return;
    }

    Json::Value payload;
    payload["port"] = discover_server_port;

    Json::StreamWriterBuilder json_writer;

    if(helpers::send_udp_broadcast("255.255.255.255", config::discover_port_dev, Json::writeString(json_writer, payload).c_str()) < 0)
    {
        auto resp = HttpResponse::newHttpResponse();
        resp->setStatusCode(k500InternalServerError);
        callback(resp);
        return;
    }

    struct sockaddr_storage their_addr{};
    socklen_t addr_size;
    int client_fd, s_ret;
    fd_set accept_fds;
    struct timeval timeout{};

    uint8_t discover_answer_buf[1];
    uint8_t discover_header_buf[1];

    controller_dbo **known_controllers = controller_dbo::get_all();

    while(true)
    {
        addr_size = sizeof(their_addr);

        FD_ZERO(&accept_fds);
        FD_SET(discover_server_socket, &accept_fds); // NOLINT(hicpp-signed-bitwise)

        timeout.tv_sec = config::discover_timeout_ms / 1000;
        timeout.tv_usec = (config::discover_timeout_ms % 1000) * 1000;

        s_ret = select(discover_server_socket + 1, &accept_fds, nullptr, nullptr, &timeout);
        if(s_ret == 0)
        {
            break;
        }
        else
        {
            if((client_fd = accept(discover_server_socket, (struct sockaddr *) &their_addr, &addr_size)) < 0)
            {
                LOG_ERROR << "Error Accepting client " << strerror(errno);
                continue;
            }

            if(recv(client_fd, discover_header_buf, 1, 0) < 0)
            {
                LOG_ERROR << "Error Receiving header from client";
                continue;
            }

            size_t payload_length = discover_header_buf[0];
            char *answer_payload = (char*)malloc((payload_length + 1) * sizeof(*answer_payload));

            if(recv(client_fd, answer_payload, payload_length, 0) < 0)
            {
                LOG_ERROR << "Error Receiving payload from client";
                continue;
            }

            struct sockaddr_in addr{};
            socklen_t client_addr_size = sizeof(struct sockaddr_in);
            if(getpeername(client_fd, (struct sockaddr *)&addr, &client_addr_size) != 0)
            {

                LOG_ERROR << "Error Receiving payload from client";
                continue;
            }

            answer_payload[payload_length] = '\0';
            std::ifstream answer_payload_stream(answer_payload);

            Json::CharReaderBuilder json_reader;
            std::string errs;
            Json::Value client_info;

            if (!Json::parseFromStream(json_reader, answer_payload_stream, &client_info, &errs))
            {
                // report to the user the failure and their locations in the document.
                std::cout  << "Failed to parse configuration\n"
                           << errs;
                return;
            }

            free(answer_payload);

            const char *discovered_id = client_info["id"].asCString();

            bool found_discovered_in_list = false;

            for(int i = 0; known_controllers[i] != nullptr; i++)
            {
                if(!found_discovered_in_list)
                {
                    if(strcmp(known_controllers[i]->id, discovered_id) == 0)
                    {
                        known_controllers[i]->active = true;
                        known_controllers[i]->update();
                        free(known_controllers[i]);
                        found_discovered_in_list = true;
                        known_controllers[i] = known_controllers[i + 1];
                    }
                }
                else
                {
                    known_controllers[i] = known_controllers[i + 1];
                }
            }

            if(!found_discovered_in_list)
            {
                controller_dbo discovered_controller{};
                strcpy(discovered_controller.ip, inet_ntoa(addr.sin_addr));
                strcpy(discovered_controller.id, discovered_id);
                strcpy(discovered_controller.name, client_info["name"].asCString());
                discovered_controller.relay_count = client_info["relay_count"].asInt();
                discovered_controller.port = client_info["port"].asInt();
                discovered_controller.active = true;

                discovered_controller.insert();
            }

            discover_answer_buf[0] = config::discover_code_accept;
            send(client_fd, discover_answer_buf, sizeof(uint8_t), 0);
            close(client_fd);
        }
    }
    for(int i = 0; known_controllers[i] != nullptr; i++)
    {
        known_controllers[i]->active = false;
        known_controllers[i]->update();
        LOG_DEBUG << "Lost: " << known_controllers[i]->name;
    }
    controller_dbo::free_list(known_controllers);

    controller_dbo **all_controllers = controller_dbo::get_all();
    Json::Value all_controllers_json(Json::arrayValue);

    for(int i = 0; all_controllers[i] != nullptr; i++)
    {
        all_controllers_json.append(all_controllers[i]->to_json());
    }

    auto resp = HttpResponse::newHttpJsonResponse(all_controllers_json);

    callback(resp);

    controller_dbo::free_list(all_controllers);

}