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

#include <Parkspace_communicator.h>
#include <dispatch_message.pb.h>
#include "PickupProcessTask.h"
#include "process_message.pb.h"
#include "command_manager.h"
#include "system_communicator.h"
#include "uniq_key.h"

PickupProcessTask::PickupProcessTask(unsigned int terminal_id)
        :m_publish_statu_thread(nullptr)
{
    m_terminor_id=terminal_id;
}
PickupProcessTask::~PickupProcessTask()
{
    //退出线程
    m_publish_exit_condition.set_pass_ever(true);
    if(m_publish_statu_thread!= nullptr)
    {
        if(m_publish_statu_thread->joinable())
        {
            m_publish_statu_thread->join();
        }
        delete m_publish_statu_thread;
        m_publish_statu_thread=nullptr;
    }
}
Error_manager PickupProcessTask::init_task(message::Car_info car_info)
{
    reset_recv_msg();

    m_car_info=car_info;

    m_step_statu=eSearch_step;
    ///创建状态发布线程
    if(m_publish_statu_thread== nullptr)
    {
        m_publish_exit_condition.reset(false, false, false);
        m_publish_statu_thread=new std::thread(publish_thread_func,this);
    }

   return SUCCESS;

}

void PickupProcessTask::reset_recv_msg()
{
    m_search_request_msg=message::Parkspace_search_request_msg();
    m_search_response_msg=message::Parkspace_search_response_msg();
    m_dispatch_request_msg=message::Dispatch_request_msg();
    m_dispatch_response_msg=message::Dispatch_response_msg();
}



/*
 * 查询车位
 */
Error_manager PickupProcessTask::search_space()
{
    /*
     * 检验汽车信息是否正常
     */
    if(m_car_info.has_car_width()==false||m_car_info.has_car_height()== false
        ||m_car_info.has_license()==false)
    {
        return Error_manager(INVALID_MESSAGE,CRITICAL_ERROR,"查询车位请求汽车信息错误");
    }

    /*
     * 检查车位管理模块是否正常
     */
    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
    if(code!=SUCCESS)
    {
        return code;
    }

    message::Base_info base_info;
    base_info.set_msg_type(message::eParkspace_search_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eParkspace);
    base_info.set_timeout_ms(1000);

    message::Parkspace_search_request_msg request;
    request.set_command_key(create_key());
    request.mutable_base_info()->CopyFrom(base_info);
    request.mutable_car_info()->CopyFrom(m_car_info);

    code = Parkspace_communicator::get_instance_pointer()->search_request(request,m_search_response_msg);
    m_step_statu=ePicking_step::eDispatch_step;
    return code;
}

/*
 * 回退查询车位
 */
Error_manager PickupProcessTask::back_search_space_step()
{
    return SUCCESS;
}

void PickupProcessTask::Main()
{
    Error_manager code;
    //进入取车流程

    while(1)
    {
        if(m_step_statu==ePicking_step::eDispatch_step)
        {
            code=dispatch_step();
            usleep(1000*1000*(rand()%3));
            LOG_IF(ERROR, code != SUCCESS) << "取车调度失败,取车终端:"<<m_terminor_id
                                           <<", 车位id:"<<m_search_response_msg.car_position().parkspace_id()
                                           <<", 车位楼层:"<<m_search_response_msg.car_position().floor()
                                           <<", 车位序号:"<<m_search_response_msg.car_position().index()
                                           <<", 车牌号:"<<m_car_info.license()
                                           <<", 库内车牌号:"<<m_search_response_msg.car_position().car_info().license();
            m_step_statu = (code != SUCCESS) ? ePicking_step::eBackDispatch_step : ePicking_step::eWait_step;
        }
        if(m_step_statu==ePicking_step::eWait_step)
        {
            code=wait_for_leave_step();
            LOG_IF(ERROR, code != SUCCESS) << "等待车辆离开失败,取车终端:"<<m_terminor_id
                                           <<", 车牌号:"<<m_car_info.license();
            m_step_statu = (code != SUCCESS) ? ePicking_step::eBackWait_step : ePicking_step::eRelease_step;
        }
        if(m_step_statu==ePicking_step::eRelease_step)
        {
            code=release_space_step();
            LOG_IF(ERROR, code != SUCCESS) << "取车释放车位失败,取车终端:"<<m_terminor_id
                                           <<", 车牌号:"<<m_car_info.license();
            if(code!=SUCCESS)
            {
                //升级故障,急停
                break;
            }
            else
            {
                m_step_statu=ePicking_step::eComplete;
            }
        }
        if(m_step_statu==eComplete)
            break;
        if(m_step_statu==ePicking_step::eBackWait_step)
        {
            code=back_wait_for_leave_step();
            if(code!=SUCCESS)
            {
                //提升错误等级为四级
                break;
            }
            else
            {
                m_step_statu=ePicking_step::eBackDispatch_step;
            }
        }
        if(m_step_statu==ePicking_step::eBackDispatch_step)
        {
            code=back_dispatch_step();
            if(code!=SUCCESS)
            {
                //提升错误等级为四级
                break;
            }
            else
            {
                m_step_statu=ePicking_step::eBackSearch_step;
            }
        }
        if(m_step_statu==ePicking_step::eBackSearch_step)
        {
            code=back_search_space_step();
            if(code!=SUCCESS)
            {
                //提升错误等级为四级,急停
                break;
            }
            else
            {
                m_step_statu=ePicking_step::eBackComplete;
            }
        }
        if(m_step_statu==ePicking_step::eBackComplete)
            break;

    }

    /*
      * 跳出循环后,判断状态,是否正常结束, 循环跳出状态只有可能是 eBackComplete(异常结束),eComplete(正常结束)
      */
    if(m_step_statu==ePicking_step::eBackComplete)
    {
        //异常结束
        usleep(1000*5000);
        LOG(ERROR)<<"异常停车,回退结束"<<"车牌号:"<<m_car_info.license()
                  <<",xxxxxxxxxxxxxx  终端:"<<m_terminor_id<<"  xxxxxxxxxxxxxx";
    }
    if(m_step_statu==ePicking_step::eComplete)
    {
        //正常结束
        usleep(1000*1000);
        LOG(WARNING)<<"停车结束,"<<"车牌号:"<<m_car_info.license()
                 <<",--------------  终端:"<<m_terminor_id<<"  --------------";
    }

}

/*
 * 执行取车动作请求,并等待执行完成
 */
Error_manager PickupProcessTask::dispatch_step()
{
    /*
  * 检查是否曾经分配过车位
  */
    if(m_search_response_msg.has_car_position()==false)
    {
        return Error_manager(FAILED,MINOR_ERROR," 取车流程释放车位请求缺少车位信息");
    }

    //2,判断调度节点状态
    Error_manager code=Dispatch_communicator::get_instance_pointer()->check_export_statu(m_terminor_id);
    if(code!=SUCCESS)
        return code;

    message::Dispatch_request_msg request;
    message::Base_info base_info;
    base_info.set_msg_type(message::eDispatch_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eDispatch);
    base_info.set_timeout_ms(1000*300); //测量超时300s
    request.mutable_base_info()->CopyFrom(base_info);

    message::Parkspace_info space_info=m_search_response_msg.car_position();
    request.set_dispatch_motion_direction(message::E_PICKUP_CAR);
    request.set_parkspace_id(space_info.parkspace_id());
    request.set_terminal_id(m_terminor_id);

    request.set_command_key(create_key());


    message::Dispatch_response_msg response;
    code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,response);
    if(code!=SUCCESS)
        return code;

    if(response.error_manager().error_code()==0) {
        return SUCCESS;
    }
    else
        return Error_manager(FAILED,MINOR_ERROR,"取车流程调度反馈错误码");

}
/*
 * 回退取车调度
 */
Error_manager PickupProcessTask::back_dispatch_step()
{
    /*
     * 关门,调度将车从出口抓回去
     */
    return SUCCESS;
}

/*
 * 等待车辆离开
 */
Error_manager PickupProcessTask::wait_for_leave_step()
{
    return SUCCESS;
}
/*
 * 回退等待车辆离开
 */
Error_manager PickupProcessTask::back_wait_for_leave_step()
{
    return SUCCESS;
}

/*
     * 清除车位表中对应的车位
     */
Error_manager PickupProcessTask::release_space_step()
{
    /*
   * 检查是否曾经分配过车位
   */
    if(m_search_response_msg.has_car_position()==false)
    {
        return Error_manager(FAILED,MINOR_ERROR," 取车流程释放车位请求缺少车位信息");
    }
    /*
     * 检查车位管理模块是否正常
     */
    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
    if(code!=SUCCESS)
        return code;

    message::Parkspace_release_request_msg request;
    message::Base_info base_info;
    base_info.set_msg_type(message::eParkspace_release_request_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eParkspace);
    base_info.set_timeout_ms(1000); //测量超时1s
    request.mutable_base_info()->CopyFrom(base_info);

    message::Parkspace_info space_info=m_search_response_msg.car_position();
    request.mutable_release_space_info()->CopyFrom(space_info);

    request.set_command_key(create_key());


    message::Parkspace_release_response_msg release_response;
    code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
    if(code!=SUCCESS)
        return code;

    if(release_response.error_manager().error_code()==0) {
        return SUCCESS;
    }
    else
        return Error_manager(FAILED,MINOR_ERROR,"取车流程parkspace release response error_code error");
}

/*
 * 发布状态线程
 */
void PickupProcessTask::publish_thread_func(PickupProcessTask* ptask)
{
    if(ptask)
    {
        ptask->publish_step_status();
    }
}
void PickupProcessTask::publish_step_status()
{
    //未收到退出信号
    while(false==m_publish_exit_condition.wait_for_ex(std::chrono::milliseconds(50)))
    {
        /*
         * 通过communicator 发布状态
         */
        if(System_communicator::get_instance_pointer())
        {
            message::Picking_process_statu_msg msg;
            if(create_step_statu_msg(msg)==SUCCESS)
            {
                System_communicator::get_instance_pointer()->post_entrance_statu(msg);
            }

        }

    }
}

/*
     * 根据当前流程状态,生成状态消息
     */
Error_manager PickupProcessTask::create_step_statu_msg(message::Picking_process_statu_msg& msg)
{
    message::Base_info base_info;
    base_info.set_msg_type(message::ePicking_process_statu_msg);
    base_info.set_sender(message::eMain);
    base_info.set_receiver(message::eEmpty);
    msg.mutable_base_info()->CopyFrom(base_info);
    msg.set_terminal_id(m_terminor_id);
    msg.set_license(m_car_info.license());

    message::Search_space_step_statu            search_step_statu;
    message::Dispatch_pick_step_statu           dispatch_step_statu;
    message::Waitfor_leave_step_statu           wait_step_statu;
    message::Release_space_step_statu           release_step_statu;
    search_step_statu.set_step_statu(message::eWaiting);
    dispatch_step_statu.set_step_statu(message::eWaiting);
    wait_step_statu.set_step_statu(message::eWaiting);
    release_step_statu.set_step_statu(message::eWaiting);

    switch (m_step_statu) {
        case ePicking_step::eSearch_step: {
            search_step_statu.set_step_statu(message::eWorking);
            if(m_step_statu==eSearch_step)
                break;
        }
        case ePicking_step::eDispatch_step: {
            search_step_statu.set_step_statu(message::eComplete);
            dispatch_step_statu.set_step_statu(message::eWorking);
            dispatch_step_statu.mutable_space_info()->CopyFrom(m_search_response_msg.car_position());
            if(m_step_statu==eDispatch_step)
                break;
        }
        case ePicking_step::eWait_step: {
            dispatch_step_statu.set_step_statu(message::eComplete);
            wait_step_statu.set_step_statu(message::eWorking);
            wait_step_statu.mutable_car_info()->CopyFrom(m_car_info);
            if(m_step_statu==ePicking_step::eWait_step)
                break;
        }
        case ePicking_step::eRelease_step:
        {
            wait_step_statu.set_step_statu(message::eComplete);
            release_step_statu.set_step_statu(message::eWorking);
            release_step_statu.mutable_space_info()->CopyFrom(m_search_response_msg.car_position());
            if(m_step_statu==ePicking_step::eRelease_step)
                break;
        }
        case ePicking_step::eComplete: {
            release_step_statu.set_step_statu(message::eComplete);
            if(m_step_statu==eComplete)
                break;
        }
        case ePicking_step::eBackWait_step :{
            wait_step_statu.set_step_statu(message::eError);
            if(m_step_statu==ePicking_step::eBackWait_step)
                break;
        }
        case eBackDispatch_step: {
            dispatch_step_statu.set_step_statu(message::eError);
            if(m_step_statu==eBackDispatch_step)
                break;
        }
        case eBackSearch_step: {
            search_step_statu.set_step_statu(message::eError);
            if(m_step_statu==eBackSearch_step)
                break;
        }
        case eBackComplete: {
            release_step_statu.set_step_statu(message::eComplete);
            if(m_step_statu==eBackComplete)
                break;
        }
        default:
            break;
    }
    msg.mutable_search_space_step()->CopyFrom(search_step_statu);
    msg.mutable_dispatch_step()->CopyFrom(dispatch_step_statu);
    msg.mutable_waitfor_leave()->CopyFrom(wait_step_statu);
    msg.mutable_release_space_step()->CopyFrom(release_step_statu);

    return SUCCESS;
}