package com.sunyo.wlpt.dispatch.controller;


import com.sunyo.wlpt.dispatch.domain.DispatchNote;
import com.sunyo.wlpt.dispatch.domain.VehicleInfo;
import com.sunyo.wlpt.dispatch.response.ResultJson;
import com.sunyo.wlpt.dispatch.service.DispatchNoteService;
import com.sunyo.wlpt.dispatch.service.VehicleInfoService;
import com.sunyo.wlpt.dispatch.utils.GetUUID;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.ibatis.annotations.Update;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static java.util.stream.Collectors.toList;

/**
 * @author 子诚
 * Description：调度车辆
 * 时间：2020/4/21 16:44
 */
@Api(value = "调度车辆业务", tags = "业务——我要调度车辆")
@RequestMapping("dispatch")
@RestController
public class DispatchController {

    @Autowired
    private VehicleInfoService vehicleInfoService;

    @Autowired
    private DispatchNoteService dispatchNoteService;

    @ApiOperation(value = "我要调度车辆", notes = "我要调度车辆")
    @PostMapping("/dispatch")
    public ResultJson dispatch(@RequestBody DispatchNote req) {
        //返回前端的
        ResultJson result = new ResultJson<>();

        /**
         * 1.获取到用户的需求
         */
        Integer vehicleNumber = req.getVehicleNumber();

        VehicleInfo vehicleInfo = new VehicleInfo();
        // 匹配车辆条件，车辆状态为空闲(1)
        vehicleInfo.setVehicleStatus("1");
        // 匹配车辆条件，车辆类型
        vehicleInfo.setVehicleType(req.getVehicleType());

        // 2.根据用户的需求（车辆类型、数量进行匹配）
        List<VehicleInfo> vehicleInfoList = vehicleInfoService.dispatchVehicle(vehicleInfo);

        for (int i = 0; i < vehicleInfoList.size(); i++) {
            System.out.println(vehicleInfoList.get(i));
        }
        // 3.对查询出来的结果进行匹配
        if (vehicleInfoList.size() >= vehicleNumber) {
            //取出前(需求)个
            List<VehicleInfo> needList = vehicleInfoList.stream()
                    .limit(vehicleNumber)
                    .collect(toList());

            for (int i = 0; i < needList.size(); i++) {
                /**
                 * 1、通知车牌号为 XX 的车被调用，任务地点：场站位置；业务类型：XXXX
                 *                  //获取车牌号
                 *                 needList.get(i).getLicensePlateNumber();
                 *                 //获取场站位置
                 *                 req.getStation();
                 *                 //获取业务类型
                 *                 req.getDispatchType();
                 *                 //获取用户的姓名
                 *                 req.getUserName();
                 *                 //获取用户的联系方式
                 *                 req.getUserMobile();
                 */

                //2.修改车辆状态
                needList.get(i).setVehicleStatus("2");
                // 将车辆状态设置为执行状态
                vehicleInfoService.updateByPrimaryKeySelective(needList.get(i));
                /**
                 * 3.生成调度表业务
                 */
                // 生成调度记录表
                DispatchNote dispatchNote = new DispatchNote();
                //记录表，设置id
                dispatchNote.setId(GetUUID.getuuid());
                //记录表，设置用户的姓名
                dispatchNote.setUserName(req.getUserName());
                //记录表，设置用户的联系方式
                dispatchNote.setUserMobile(req.getUserMobile());
                //记录表，设置车牌号
                dispatchNote.setLicensePlateNumber(needList.get(i).getLicensePlateNumber());
                //记录表，设置调度业务类型
                dispatchNote.setDispatchType(req.getDispatchType());
                //记录表，设置场站位置
                dispatchNote.setStation(req.getStation());
                //记录表，每条记录表的车辆数为1
                dispatchNote.setVehicleNumber(1);
                //记录表，设置车辆类型
                dispatchNote.setVehicleType(req.getVehicleType());
                //记录表，设置记录状态为执行状态（2）
                dispatchNote.setStatus("2");
                //记录表，设置创建时间
                dispatchNote.setGmtCreate(new Date());
                // 生成调度记录表
                dispatchNoteService.insertSelective(dispatchNote);
            }
            //车辆匹配成功，返回车辆信息
            result.setData(needList);
            result.setCode("200");
            result.setMsg("车辆调度成功！");
        } else {
            //车辆匹配失败
            result.setCode("400");
            result.setMsg("车辆繁忙，请稍后重试！");
        }
        return result;
    }

    @ApiOperation(value = "开始工作", notes = "车辆被调度后，开始工作的时刻")
    @PutMapping("/startTask")
    public void startTask(@RequestBody DispatchNote req) {
        /**
         * 设置调度记录表，开始任务时间(由客户端传递过来，比较精确)
         */
        req.setBeginTime(new Date());
        dispatchNoteService.updateByPrimaryKeySelective(req);
    }

    @ApiOperation(value = "完成工作", notes = "车辆被调度后，完成工作的时刻")
    @PutMapping("/completeTask")
    public void completeTask(@RequestBody DispatchNote req) {
        /**
         * 车辆信息表，修改
         * 1.设置车辆信息表，为空闲状态(1)
         * 2.设置车辆信息表开始空闲时间（任务的完成时间）
         */
        // 根据记录表中的车牌号，获取到车辆信息
        String licensePlateNumber = req.getLicensePlateNumber();
        VehicleInfo vehicleInfo = vehicleInfoService.selectByLPN(licensePlateNumber);
        //设置车辆信息表，为空闲状态(1)
        vehicleInfo.setVehicleStatus("1");
        //设置车辆信息表,开始空闲时间
        Date nowTime = new Date();
        vehicleInfo.setFreetime(nowTime);
        vehicleInfoService.updateByPrimaryKeySelective(vehicleInfo);
        /**
         * 调度记录表，修改
         * 1.设置调度记录，完成时间
         * 2.设置调度记录，完成状态(1)
         */
        req.setStatus("1");
        req.setEndTime(nowTime);
        dispatchNoteService.updateByPrimaryKeySelective(req);
    }

    @ApiOperation(value = "取消调度车辆", notes = "判断了多种情况下，取消调度车辆")
    @PutMapping("/cancel")
    public ResultJson cancel(@RequestBody DispatchNote req) {
        ResultJson result = new ResultJson();
        /**
         * 根据记录表中的车牌号，获取到车辆信息
         */
        String licensePlateNumber = req.getLicensePlateNumber();
        VehicleInfo vehicleInfo = vehicleInfoService.selectByLPN(licensePlateNumber);

        /**
         * 判断? 车辆是否为执行状态(2)
         */
        String workingStatus = "2";
        if (workingStatus.equals(vehicleInfo.getVehicleStatus())) {
            /**
             * 车辆状态，为执行状态(2),
             * 判断调度记录表,开始时间是否为null
             * 为null==>还没有开启调度任务
             */
            if (req.getBeginTime() == null) {
                /**
                 * 设置车辆状态，为空闲状态（"1"）
                 * 设置车辆，开始空闲时间
                 * 将调度记录表的状态修改为撤销（取消）状态（"3"）
                 */
                vehicleInfo.setVehicleStatus("1");
                vehicleInfo.setFreetime(new Date());
                vehicleInfoService.updateByPrimaryKeySelective(vehicleInfo);
                req.setStatus("3");
                dispatchNoteService.updateByPrimaryKeySelective(req);
                result.setMsg("该调度车辆，已经取消");
            } else {
                /**
                 * 记录的开始时间不是null==>已经开始调度了
                 * 所以，请求人工帮助
                 */
                result.setCode("400");
                result.setMsg("请求，人工介入");
            }
        } else {
            /**
             * 车辆的状态不是执行状态（2），也就是说
             * 将调度记录表的状态修改为撤销（取消）状态（"3"）
             */
            req.setStatus("3");
            dispatchNoteService.updateByPrimaryKeySelective(req);
            result.setMsg("该调度车辆，已经取消");
        }
        return result;
    }
}