package com.ruoyi.order.controller;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.GlobalException;
import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.order.entity.ChangeDispatch;
import com.ruoyi.order.entity.Order;
import com.ruoyi.order.request.ChangeDispatchRequest;
import com.ruoyi.order.service.ChangeDispatchService;
import com.ruoyi.order.service.OrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 改派管理 前端控制器
 * </p>
 *
 * @author hjl
 * @since 2024-05-31
 */
@RestController
@RequestMapping("/changeDispatch")
@Api(tags = {"后台-系统设置-订单改派管理"})
public class ChangeDispatchController {

    @Resource
    private ChangeDispatchService changeDispatchService;
    @Resource
    private OrderService orderService;

    /**
     * 订单改派分页列表
     *
     * @param request 查询参数
     */
    @RequiresPermissions("reassignment_apply")
    @ApiOperation(value = "订单改派分页查询列表", tags = {"后台-系统设置-订单改派管理"})
    @PostMapping(value = "/page")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "师傅名称", name = "workerName", dataType = "String"),
            @ApiImplicitParam(value = "订单编号", name = "orderNumber", dataType = "String"),
            @ApiImplicitParam(value = "下单用户名称", name = "userName", dataType = "String"),
            @ApiImplicitParam(value = "页码", name = "pageNum", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "每页条数", name = "pageSize", dataType = "Integer", required = true)
    })
    public R<Page<ChangeDispatch>> queryPageList(@RequestBody ChangeDispatchRequest request) {
        Page<ChangeDispatch> page = changeDispatchService.queryPageList(request, Page.of(request.getPageNum(),
                request.getPageSize()));
        for (ChangeDispatch record : page.getRecords()) {
            Order byId = orderService.getById(record.getOrderId());
//            if (byId!=null){
//                record.setType(byId.getType());
//
//            }
        }
        return R.ok(page);
    }

    /**
     * 订单改派详情
     *
     * @param changeDispatch 订单改派信息
     */
    @ApiOperation(value = "新增订单改派", tags = {"后台-系统设置-订单改派管理"})
    @PostMapping(value = "/save")
    public R<Boolean> save(@RequestBody ChangeDispatch changeDispatch) {
        return R.ok(changeDispatchService.save(changeDispatch));
    }

    /**
     * 订单改派详情
     *
     * @param changeDispatch 订单改派信息
     */
    @ApiOperation(value = "订单改派新逻辑", tags = {"后台-系统设置-订单改派管理"})
    @PostMapping(value = "/saveRecord")
    public R<Boolean> saveRecord(@RequestBody ChangeDispatch changeDispatch) {
        String orderId = changeDispatch.getOrderId();
        ChangeDispatch record = changeDispatchService.lambdaQuery()
                .eq(ChangeDispatch::getOrderId, orderId)
                .orderByDesc(ChangeDispatch::getCreateTime)
                .last("limit 1").one();
        boolean result = true;
        if (null == record || record.getState() == 1 || record.getState() == 2) {
            result = changeDispatchService.save(changeDispatch);
        } else {
            changeDispatchService.lambdaUpdate()
                    .set(ChangeDispatch::getState, Constants.ONE)
                    .eq(ChangeDispatch::getId, record.getId()).update();
        }
        return R.ok(result);
    }

    /**
     * 订单改派 -远程调用
     *
     * @param changeDispatch 订单改派信息
     */
    @ApiOperation(value = "新增订单改派", tags = {"后台-系统设置-订单改派管理"})
    @PostMapping(value = "/changeDispatchSave")
    public R<Boolean> changeDispatchSave(@RequestBody ChangeDispatch changeDispatch) {
        return R.ok(changeDispatchService.save(changeDispatch));
    }

    /**
     * 订单改派详情
     *
     * @param id 订单改派id
     */
    @ApiOperation(value = "订单改派详情", tags = {"后台-系统设置-订单改派管理"})
    @GetMapping(value = "/detail")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单改派id", name = "id", dataType = "Integer", required = true)
    })
    public R<ChangeDispatch> detail(@RequestParam("id") String id) {
        return R.ok(changeDispatchService.lambdaQuery().eq(ChangeDispatch::getId, id)
                .eq(ChangeDispatch::getIsDelete, 0).one());
    }

    /**
     * 订单改派详情 远程调用
     *
     * @param id 订单id
     */
    @GetMapping(value = "/one")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单改派id", name = "id", dataType = "Integer", required = true)
    })
    public R<ChangeDispatch> one(@RequestParam("id") Integer id) {
        ChangeDispatch changeDispatch = changeDispatchService.lambdaQuery()
                .eq(ChangeDispatch::getOrderId, id)
                .eq(ChangeDispatch::getState, Constants.ZERO)
                .one();
        return R.ok(changeDispatch);
    }

    /**
     * 订单改派详情 远程调用
     *
     * @param id 订单id
     */
    @GetMapping(value = "/changeDispatchOne")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单改派id", name = "id", dataType = "String", required = true)
    })
    public R<ChangeDispatch> changeDispatchOne(@RequestParam("id") String id) {
        ChangeDispatch changeDispatch = changeDispatchService.lambdaQuery()
                .eq(ChangeDispatch::getOrderId, id)
                .eq(ChangeDispatch::getState, Constants.ZERO)
                .orderByDesc(ChangeDispatch::getCreateTime)
                .last("limit 1")
                .one();
        return R.ok(changeDispatch);
    }

    /**
     * 拒绝订单改派申请
     *
     * @param id 订单id
     */
    @GetMapping(value = "/refuseChangeDispatch")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单改派id", name = "id", dataType = "String", required = true)
    })
    public R<Boolean> refuseChangeDispatch(@RequestParam("id") String id) {
        ChangeDispatch changeDispatch = changeDispatchService.lambdaQuery()
                .eq(ChangeDispatch::getId, id)
                .eq(ChangeDispatch::getIsDelete, Constants.ZERO)
                .one();
        if (null == changeDispatch) {
            throw new GlobalException("改派申请不存在或已删除！");
        }
        changeDispatch.setState(Constants.TWO);
        boolean update = changeDispatchService.updateById(changeDispatch);
        // 订单重新派给提交申请的师傅
        Order order = orderService.lambdaQuery()
                .eq(Order::getId, changeDispatch.getOrderId())
                .eq(Order::getIsDelete, 0).one();
        order.setState(Constants.ONE);
        Integer serverId = order.getServerId();
        return R.ok(update && orderService.updateById(order));
    }

    /**
     * 根据id批量删除订单改派
     *
     * @param ids 订单改派多条id拼接
     */
    @RequiresPermissions("reassignment_apply")
    @ApiOperation(value = "批量删除订单改派", tags = {"后台-系统设置-订单改派管理"})
    @GetMapping(value = "/batchDelete")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "多条订单改派id ',' 拼接", name = "ids", dataType = "String", required = true)
    })
    public R<String> batchDelete(@RequestParam String ids) {
        List<String> idList = Arrays.stream(ids.split(",")).collect(Collectors.toList());
        List<ChangeDispatch> list = changeDispatchService.lambdaQuery().in(ChangeDispatch::getId, idList).list();
        list.forEach(data -> data.setIsDelete(1));
        return changeDispatchService.updateBatchById(list) ? R.ok() : R.fail();
    }

    /**
     * 订单改派师傅
     *
     * @param changeId 改派订单id
     * @param workerId 师傅id
     */
    @RequiresPermissions("reassignment_apply")
    @ApiOperation(value = "订单改派师傅", tags = {"后台-系统设置-订单改派管理"})
    @GetMapping(value = "/changeWorker")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "改派订单id", name = "changeId", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "师傅id", name = "workerId", dataType = "Integer", required = true),
            @ApiImplicitParam(value = "师傅姓名", name = "name", dataType = "String", required = true),
            @ApiImplicitParam(value = "师傅电话", name = "phone", dataType = "String", required = true)
    })
    public R<Boolean> changeWorker(@RequestParam("changeId") String changeId, @RequestParam("workerId") Integer workerId,
                                   @RequestParam("name") String name, @RequestParam("phone") String phone) {
        ChangeDispatch changeDispatch = changeDispatchService.lambdaQuery().eq(ChangeDispatch::getId, changeId)
                .eq(ChangeDispatch::getIsDelete, 0).one();
        if (null == changeDispatch || Constants.ONE.equals(changeDispatch.getState())) {
            throw new GlobalException("改派申请不存在或已改派！");
        }
        Order order = orderService.lambdaQuery().eq(Order::getId, changeDispatch.getOrderId())
                .eq(Order::getIsDelete, 0).one();
        if (null == order) {
            throw new GlobalException("订单不存在！");
        }
        // 更改订单信息为再投单
        boolean orderUpdate = orderService.lambdaUpdate()
                .set(Order::getIsReinvest, Constants.ONE)
                .set(Order::getAcceptTime, new Date())
                .set(Order::getArriveTime, null)
                .set(Order::getCompleteTime, null).set(Order::getAcceptTime, LocalDateTime.now())
                // 原订单状态改为 1:待上门，已选择师傅
                .set(Order::getState, Constants.ONE).set(Order::getServerId, workerId).set(Order::getServerName, name).set(Order::getServerPhone, phone)
                .eq(Order::getId, order.getId()).update();
        // 改派信息
        boolean update = changeDispatchService.lambdaUpdate().set(ChangeDispatch::getState, 1)
                .eq(ChangeDispatch::getId, changeId).eq(ChangeDispatch::getIsDelete, 0).update();
        return R.ok(orderUpdate && update);
    }

}