package com.ruoyi.web.app;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.ruoyi.bst.order.domain.OrderQuery;
import com.ruoyi.bst.order.domain.OrderVO;
import com.ruoyi.bst.order.domain.dto.OrderCalcFeeDTO;
import com.ruoyi.bst.order.domain.dto.OrderCalcPrePriceDTO;
import com.ruoyi.bst.order.domain.dto.OrderChangeDeviceDTO;
import com.ruoyi.bst.order.domain.dto.OrderCloseDeviceDTO;
import com.ruoyi.bst.order.domain.dto.OrderCreateDTO;
import com.ruoyi.bst.order.domain.dto.OrderEndDTO;
import com.ruoyi.bst.order.domain.dto.OrderOpenDeviceDTO;
import com.ruoyi.bst.order.domain.enums.OrderReturnType;
import com.ruoyi.bst.order.domain.enums.OrderStatus;
import com.ruoyi.bst.order.domain.vo.OrderEndVO;
import com.ruoyi.bst.order.domain.vo.OrderFeeVO;
import com.ruoyi.bst.order.domain.vo.OrderPrePriceVO;
import com.ruoyi.bst.order.service.OrderConverter;
import com.ruoyi.bst.order.service.OrderService;
import com.ruoyi.bst.order.service.OrderValidator;
import com.ruoyi.common.annotation.Anonymous;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.LogBizType;
import com.ruoyi.common.utils.ServiceUtil;

import io.swagger.annotations.ApiOperation;

@RestController
@RequestMapping("/app/order")
public class AppOrderController extends BaseController {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderConverter orderConverter;

    @Autowired
    private OrderValidator orderValidator;

    @ApiOperation("获取我的订单列表")
    @GetMapping("/mineList")
    public TableDataInfo getMineList(OrderQuery query) {
        query.setUserId(getUserId());
        startPage();
        List<OrderVO> list = orderService.selectOrderList(query);
        return getDataTable(list);
    }

    @ApiOperation("获取我的订单详情")
    @GetMapping("/mineDetail")
    public AjaxResult getMineDetail(Long id) {
        OrderQuery query = new OrderQuery();
        query.setId(id);
        query.setUserId(getUserId());
        return success(orderService.selectOne(query));
    }

    @ApiOperation("获取我正在进行的订单")
    @GetMapping("/mineProcessing")
    public AjaxResult getMineProcessing() {
        OrderQuery query = new OrderQuery();
        query.setUserId(getUserId());
        query.setStatus(OrderStatus.PROCESSING.getCode());
        return success(orderService.selectOne(query));
    }

    @ApiOperation("支付前计算订单价格")
    @PostMapping("/calculatePrice")
    @Log(title = "支付前计算订单价格", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.SUIT)
    @Anonymous
    public AjaxResult calculatePrice(@RequestBody @Validated OrderCalcPrePriceDTO dto) {
        OrderPrePriceVO vo = orderConverter.toOrderPrePriceVO(dto);
        if (vo == null) {
            return error("计算价格失败，请检查");
        }
        return success(vo);
    }

    @ApiOperation("下单并支付")
    @PostMapping
    @Log(title = "下单并支付", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.SUIT)
    public AjaxResult createOrder(@RequestBody @Validated OrderCreateDTO dto) {
        dto.setUserId(getUserId());
        return success(orderService.createOrder(dto));
    }

    @ApiOperation("结束订单（还车）")
    @PutMapping("/end")
    @Log(title = "结束订单（还车）", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.ORDER)
    public AjaxResult endOrder(@RequestBody @Validated OrderEndDTO dto) {
        OrderVO order = orderService.selectOrderById(dto.getOrderId());
        ServiceUtil.assertion(!orderValidator.canEnd(order, getUserId()), "您无权结束ID为%s的订单", order.getId());
        dto.setReturnType(OrderReturnType.NORMAL.getCode());
        dto.setEndReason("用户【" + getNickName() + "】手动还车");
        OrderEndVO vo = orderService.endOrder(dto);
        if (vo.getDb() > 0) {
            return success(vo);
        }
        return error("关闭订单失败");
    }

    @ApiOperation("计算订单费用")
    @PostMapping("/calcFee")
    @Log(title = "计算订单费用", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.ORDER)
    public AjaxResult calcFee(@RequestBody @Validated OrderCalcFeeDTO dto) {
        OrderFeeVO fee = orderService.calcFee(dto);
        ServiceUtil.assertion(fee == null, "价格计算失败");
        return success(fee);
    }

    @ApiOperation("订单开锁")
    @PutMapping("/openDevice")
    @Log(title = "订单开锁", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.ORDER)
    public AjaxResult openDevice(@Validated OrderOpenDeviceDTO dto) {
        OrderVO order = orderService.selectOrderById(dto.getOrderId());
        ServiceUtil.assertion(order == null, "订单不存在");
        ServiceUtil.assertion(!orderValidator.canOpenDevice(order, getUserId()), "您无权操作ID为%s的订单设备开启", order.getId());
        ServiceUtil.assertion(orderValidator.isTimeout(order), "当前订单已超时，请在安全的区域还车");
        dto.setRequiredIot(true);
        return success(orderService.openDevice(dto));
    }

    @ApiOperation("临时锁车")
    @PutMapping("/closeDevice")
    @Log(title = "临时锁车", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.ORDER)
    public AjaxResult closeDevice(@Validated OrderCloseDeviceDTO dto) {
        OrderVO order = orderService.selectOrderById(dto.getOrderId());
        ServiceUtil.assertion(order == null, "订单不存在");
        ServiceUtil.assertion(!orderValidator.canCloseDevice(order, getUserId()), "您无权操作ID为%s的订单设备关闭", order.getId());
        ServiceUtil.assertion(orderValidator.isTimeout(order), "当前订单已超时，请在安全的区域还车");
        dto.setRequiredIot(true);
        return success(orderService.closeDevice(dto));
    }

    @ApiOperation("换车")
    @PutMapping("/changeDevice")
    @Log(title = "换车", businessType = BusinessType.OTHER, bizIdName = "arg0", bizType = LogBizType.ORDER)
    public AjaxResult changeDevice(@RequestBody @Validated OrderChangeDeviceDTO dto) {
        OrderVO order = orderService.selectOrderById(dto.getOrderId());
        ServiceUtil.assertion(!orderValidator.canChangeDevice(order, getUserId()), "您无权操作ID为%s的订单换车", order.getId());
        ServiceUtil.assertion(orderValidator.isTimeout(order), "当前订单已超时，请在安全的区域还车");
        dto.setUserId(getUserId());
        dto.setUserName(getNickName());
        return toAjax(orderService.changeDevice(dto));
    }

}