//
// Created by zx on 2020/7/9.
//

#include "Parkspace_communicator.h"

namespace message {
    bool operator<(const message::Parkspace_allocation_request_msg &msg1,
                   const message::Parkspace_allocation_request_msg &msg2) {
        return (msg1.command_id() < msg2.command_id());
    }

    bool operator==(const message::Parkspace_allocation_request_msg &msg1,
                    const message::Parkspace_allocation_request_msg &msg2)
    {
        if (msg1.base_info().msg_type() == msg2.base_info().msg_type()
            && msg1.base_info().sender() == msg2.base_info().sender()
            && msg1.base_info().receiver() == msg2.base_info().receiver()
            && msg1.command_id() == msg2.command_id()
            && msg1.terminal_id() == msg2.terminal_id()){
            return true;
        }
        return false;
    }

    bool operator<(const message::Parkspace_search_request_msg &msg1,
            const message::Parkspace_search_request_msg &msg2) {
        return (msg1. command_id() < msg2.command_id());
    }

bool operator==(const message::Parkspace_search_request_msg &msg1, const message::Parkspace_search_request_msg &msg2)
{
    if (msg1.base_info().msg_type() == msg2.base_info().msg_type()
        && msg1.base_info().sender() == msg2.base_info().sender()
        && msg1.base_info().receiver() == msg2.base_info().receiver()
        && msg1.command_id() == msg2.command_id()) {
        return true;
    }
    return false;
}

bool operator<(const message::Parkspace_release_request_msg &msg1, const message::Parkspace_release_request_msg &msg2)
{
    return (msg1.command_id() < msg2.command_id());
}

bool operator==(const message::Parkspace_release_request_msg &msg1, const message::Parkspace_release_request_msg &msg2)
{
    if (msg1.base_info().msg_type() == msg2.base_info().msg_type()
        && msg1.base_info().sender() == msg2.base_info().sender()
        && msg1.base_info().receiver() == msg2.base_info().receiver()
        && msg1.command_id() == msg2.command_id()) {
        return true;
    }
    return false;
}

}


Parkspace_communicator::~Parkspace_communicator(){}
/*
 * 请求分配车位
 */
Error_manager Parkspace_communicator::alloc_request(message::Parkspace_allocation_request_msg& request,message::Parkspace_allocation_response_msg& result)
{
    /*
     * 检查request合法性,以及模块状态
     */
    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eTable)
        return Error_manager(PARKSPACE_ALLOC_REQUEST_INVALID,MINOR_ERROR,"parkspace alloc request invalid");

    if(m_alloc_table.find(request)==true)
        return Error_manager(PARKSPACE_ALLOC_REQUEST_REPEATED,MAJOR_ERROR," parkspace alloc request repeated");
    //设置超时,若没有设置,默认1000
    int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():1000;
    //向测量节点发送测量请求,并记录请求

    Error_manager code;
    Communication_message message;

    message::Base_info base_msg;
    base_msg.set_msg_type(message::eParkspace_allocation_request_msg);
    base_msg.set_sender(message::eMain);
    base_msg.set_receiver(message::eTable);
    base_msg.set_timeout_ms(timeout);
    message.reset(base_msg,request.SerializeAsString());

    code=encapsulate_msg(&message);
    if(code!=SUCCESS)
        return code;
    //循环查询请求是否被处理
    auto start_time=std::chrono::system_clock::now();
    double time=0;
    do{
        //查询到记录
        message::Parkspace_allocation_response_msg response;
        ///查询是否存在,并且删除该记录,
        if(m_alloc_table.find(request,response))
        {
            //判断是否接收到回应,若回应信息被赋值则证明有回应
            if (response.has_base_info() && response.has_command_id())
            {
                message::Base_info response_base = response.base_info();
                //检查类型是否匹配
                if (response_base.msg_type() != message::eParkspace_allocation_response_msg) {
                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
                                         "parkspace alloc response msg type error");
                }
                //检查基本信息是否匹配
                if (response_base.sender() != message::eTable ||
                    response_base.receiver() != message::eMain ||
                    response.command_id() != request.command_id()) {
                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_INFO_ERROR, MAJOR_ERROR,
                                         "parkspace alloc response msg info error");
                }
                result = response;
                m_alloc_table.erase(request);

                return SUCCESS;

            }
        }
        else
        {
            //未查询到记录,任务已经被提前取消,记录被删除
            return Error_manager(PARKSPACE_ALLOC_REQUEST_CANCELED,MINOR_ERROR,"parkspace alloc request canceled");
        }

        auto end_time=std::chrono::system_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
        std::this_thread::yield();
        usleep(1000);
    }while(time<double(timeout));
    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace alloc request timeout");

}

/*
 * 查询车辆所在位置请求
 */
Error_manager Parkspace_communicator::search_request(message::Parkspace_search_request_msg& request,
        message::Parkspace_search_response_msg& result)
{
    /*
     * 检查request合法性,以及模块状态
     */
    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eTable)
        return Error_manager(PARKSPACE_SEARCH_REQUEST_INVALID,MINOR_ERROR,"parkspace search request invalid");

    if(m_search_table.find(request)==true)
        return Error_manager(PARKSPACE_SEARCH_REQUEST_REPEATED,MAJOR_ERROR," parkspace search request repeated");
    //设置超时,若没有设置,默认1000
    int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():1000;
    //向测量节点发送测量请求,并记录请求

    Error_manager code;
    Communication_message message;

    message::Base_info base_msg;
    base_msg.set_msg_type(message::eParkspace_search_request_msg);
    base_msg.set_sender(message::eMain);
    base_msg.set_receiver(message::eTable);
    base_msg.set_timeout_ms(timeout);
    message.reset(base_msg,request.SerializeAsString());

    code=encapsulate_msg(&message);
    if(code!=SUCCESS)
        return code;
    //循环查询请求是否被处理
    auto start_time=std::chrono::system_clock::now();
    double time=0;
    do{
        //查询到记录
        message::Parkspace_search_response_msg response;
        ///查询是否存在,并且删除该记录,
        if(m_search_table.find(request,response))
        {
            //判断是否接收到回应,若回应信息被赋值则证明有回应
            if (response.has_base_info() && response.has_command_id())
            {
                message::Base_info response_base = response.base_info();
                //检查类型是否匹配
                if (response_base.msg_type() != message::eParkspace_search_response_msg) {
                    return Error_manager(PARKSPACE_SEARCH_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
                                         "parkspace search response msg type error");
                }
                //检查基本信息是否匹配
                if (response_base.sender() != message::eTable ||
                    response_base.receiver() != message::eMain ||
                    response.command_id() != request.command_id()) {
                    return Error_manager(PARKSPACE_SEARCH_RESPONSE_INFO_ERROR, MAJOR_ERROR,
                                         "parkspace search response msg info error");
                }
                result = response;
                m_search_table.erase(request);

                return SUCCESS;

            }
        }
        else
        {
            //未查询到记录,任务已经被提前取消,记录被删除
            return Error_manager(PARKSPACE_SEARCH_REQUEST_CANCELED,MINOR_ERROR,"parkspace search request canceled");
        }

        auto end_time=std::chrono::system_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
        std::this_thread::yield();
        usleep(1000);
    }while(time<double(timeout));
    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace search request timeout");
}

/*
 * 释放车位请求(停车失败或者取车完成时调用)
 */
Error_manager Parkspace_communicator::release_request(message::Parkspace_release_request_msg& request,
        message::Parkspace_release_response_msg& result)
{
    /*
    * 检查request合法性,以及模块状态
    */
    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eTable)
        return Error_manager(PARKSPACE_RELEASE_REQUEST_INVALID,MINOR_ERROR,"parkspace release request invalid");

    if(m_release_table.find(request)==true)
        return Error_manager(PARKSPACE_RELEASE_REQUEST_REPEATED,MAJOR_ERROR," parkspace release request repeated");
    //设置超时,若没有设置,默认1000
    int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():1000;
    //向测量节点发送测量请求,并记录请求

    Error_manager code;
    Communication_message message;

    message::Base_info base_msg;
    base_msg.set_msg_type(message::eParkspace_release_request_msg);
    base_msg.set_sender(message::eMain);
    base_msg.set_receiver(message::eTable);
    base_msg.set_timeout_ms(timeout);
    message.reset(base_msg,request.SerializeAsString());

    code=encapsulate_msg(&message);
    if(code!=SUCCESS)
        return code;
    //循环查询请求是否被处理
    auto start_time=std::chrono::system_clock::now();
    double time=0;
    do{
        //查询到记录
        message::Parkspace_release_response_msg response;
        ///查询是否存在,并且删除该记录,
        if(m_release_table.find(request,response))
        {
            //判断是否接收到回应,若回应信息被赋值则证明有回应
            if (response.has_base_info() && response.has_command_id())
            {
                message::Base_info response_base = response.base_info();
                //检查类型是否匹配
                if (response_base.msg_type() != message::eParkspace_release_response_msg) {
                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
                                         "parkspace release response msg type error");
                }
                //检查基本信息是否匹配
                if (response_base.sender() != message::eTable ||
                    response_base.receiver() != message::eMain ||
                    response.command_id() != request.command_id()) {
                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
                                         "parkspace release response msg info error");
                }
                result = response;
                m_release_table.erase(request);

                return SUCCESS;

            }
        }
        else
        {
            //未查询到记录,任务已经被提前取消,记录被删除
            return Error_manager(PARKSPACE_RELEASE_REQUEST_CANCELED,MINOR_ERROR,"parkspace release request canceled");
        }

        auto end_time=std::chrono::system_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
        std::this_thread::yield();
        usleep(1000);
    }while(time<double(timeout));
    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace release request timeout");
}


Error_manager Parkspace_communicator::check_statu()
{
    return SUCCESS;
}



Parkspace_communicator::Parkspace_communicator(){}

Error_manager Parkspace_communicator::encapsulate_msg(Communication_message* message)
{
    switch (message->get_message_type())
    {
        case Communication_message::eParkspace_allocation_request_msg:
        {
            message::Parkspace_allocation_request_msg request;
            request.ParseFromString(message->get_message_buf());
            //记录数据
            m_alloc_table[request]=message::Parkspace_allocation_response_msg();
            //发送请求
            return Communication_socket_base::encapsulate_msg(message);
        }
        case Communication_message::eParkspace_search_request_msg:
        {
            message::Parkspace_search_request_msg request;
            request.ParseFromString(message->get_message_buf());
            //记录数据
            m_search_table[request]=message::Parkspace_search_response_msg();
            //发送请求
            return Communication_socket_base::encapsulate_msg(message);
        }
        case Communication_message::eParkspace_release_request_msg:
        {
            message::Parkspace_release_request_msg request;
            request.ParseFromString(message->get_message_buf());
            //记录数据
            m_release_table[request]=message::Parkspace_release_response_msg();
            //发送请求
            return Communication_socket_base::encapsulate_msg(message);
        }
        default:
            return Error_manager(PARKSPACE_REQUEST_MSG_TYPE_ERROR,NEGLIGIBLE_ERROR,"parkspace message table is not exist");
    }

}
Error_manager Parkspace_communicator::execute_msg(Communication_message* p_msg)
{
    if(p_msg== nullptr)
        return Error_manager(POINTER_IS_NULL,CRITICAL_ERROR,"parkspace response msg pointer is null");


    //车位response消息
    switch (p_msg->get_message_type())
    {
        ///测量结果反馈消息
        case Communication_message::eParkspace_allocation_response_msg:
        {
            message::Parkspace_allocation_response_msg response;
            response.ParseFromString(p_msg->get_message_buf());
            message::Parkspace_allocation_request_msg request=create_request_by_response(response);
            ///查询请求表是否存在,并且更新
            if(m_alloc_table.find_update(request,response))
            {
                return Error_manager(PARKSPACE_ALLOCMSG_RESPONSE_HAS_NO_REQUEST,NEGLIGIBLE_ERROR,"parkspace alloc response without request");
            }

            break;
        }
        case Communication_message::eParkspace_search_response_msg:
        {
            message::Parkspace_search_response_msg response;
            response.ParseFromString(p_msg->get_message_buf());
            message::Parkspace_search_request_msg request=create_request_by_response(response);
            ///查询请求表是否存在,并且更新
            if(m_search_table.find_update(request,response))
            {
                return Error_manager(PARKSPACE_SEARCHMSG_RESPONSE_HAS_NO_REQUEST,NEGLIGIBLE_ERROR,"parkspace search response without request");
            }
            break;
        }
        case Communication_message::eParkspace_release_response_msg:
        {
            message::Parkspace_release_response_msg response;
            response.ParseFromString(p_msg->get_message_buf());
            message::Parkspace_release_request_msg request=create_request_by_response(response);
            ///查询请求表是否存在,并且更新
            if(m_release_table.find_update(request,response))
            {
                return Error_manager(PARKSPACE_RELEASEMSG_RESPONSE_HAS_NO_REQUEST,NEGLIGIBLE_ERROR,"parkspace release response without request");
            }
            break;
        }
            ///测量系统状态
        case Communication_message::eParkspace_allocation_status_msg:
        {
            m_parkspace_status_msg=*p_msg;
            break;
        }
    }
    return SUCCESS;

}
/*
 * 检测消息类型是否可被处理
 */
Error_manager Parkspace_communicator::check_msg(Communication_message* p_msg)
{
    //通过 p_msg->get_message_type() 和 p_msg->get_receiver() 判断这条消息是不是给我的.
    //子类重载时, 增加自己模块的判断逻辑, 以后再写.
    if ( (p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_response_msg
        ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_search_response_msg
        ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_release_response_msg
        ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_status_msg)
         && p_msg->get_receiver() == Communication_message::Communicator::eMain )
    {
        return Error_code::SUCCESS;
    }
    else
    {
        //认为接受人
        return Error_code::INVALID_MESSAGE;
    }
    return SUCCESS;
}
/*
 * 心跳发送函数,重载
 */
Error_manager Parkspace_communicator::encapsulate_send_data()
{
    return SUCCESS;
}
//检查消息是否可以被解析, 需要重载
Error_manager Parkspace_communicator::check_executer(Communication_message* p_msg)
{
    return SUCCESS;
}

/*
 * 根据接收到的response,生成对应的 request
 */
message::Parkspace_allocation_request_msg
Parkspace_communicator::create_request_by_response(message::Parkspace_allocation_response_msg& response)
{
    message::Parkspace_allocation_request_msg request;
    message::Base_info baseInfo;
    baseInfo.set_msg_type(message::eLocate_request_msg);
    baseInfo.set_sender(response.base_info().sender());
    baseInfo.set_receiver(response.base_info().receiver());
    request.mutable_base_info()->CopyFrom(baseInfo);
    request.set_command_id(response.command_id());
    request.set_terminal_id(response.command_id());
    return request;
}

message::Parkspace_search_request_msg
Parkspace_communicator::create_request_by_response(message::Parkspace_search_response_msg& response)
{
    message::Parkspace_search_request_msg request;
    message::Base_info baseInfo;
    baseInfo.set_msg_type(message::eLocate_request_msg);
    baseInfo.set_sender(response.base_info().sender());
    baseInfo.set_receiver(response.base_info().receiver());
    request.mutable_base_info()->CopyFrom(baseInfo);
    request.set_command_id(response.command_id());


    return request;
}

message::Parkspace_release_request_msg
Parkspace_communicator::create_request_by_response(message::Parkspace_release_response_msg& response)
{
    message::Parkspace_release_request_msg request;
    message::Base_info baseInfo;
    baseInfo.set_msg_type(message::eLocate_request_msg);
    baseInfo.set_sender(response.base_info().sender());
    baseInfo.set_receiver(response.base_info().receiver());
    request.mutable_base_info()->CopyFrom(baseInfo);
    request.set_command_id(response.command_id());
    return request;
}