package com.ltkj.web.controller.mall;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ltkj.common.core.domain.AjaxResult;
import com.ltkj.common.exception.user.DataNotFoundException;
import com.ltkj.framework.config.UserHoder;
import com.ltkj.hosp.domain.TjCustomer;
import com.ltkj.hosp.domain.Wxuser;
import com.ltkj.hosp.service.ITjCustomerService;
import com.ltkj.mall.domain.MallAftersale;
import com.ltkj.mall.domain.MallOrder;
import com.ltkj.mall.domain.MallOrderGoods;
import com.ltkj.mall.mallOrderUtils.AftersaleConstant;
import com.ltkj.mall.mallOrderUtils.OrderConstants;
import com.ltkj.mall.mallOrderUtils.OrderHandleOption;
import com.ltkj.mall.mallOrderUtils.OrderUtil;
import com.ltkj.mall.service.IMallAftersaleService;
import com.ltkj.mall.service.IMallOrderGoodsService;
import com.ltkj.mall.service.IMallOrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.weaver.loadtime.Aj;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.math.BigDecimal;
import java.util.*;

/**
 * @Company: 西安路泰科技有限公司
 * @Author: lige
 * @Date: 2023/7/14 09:57
 */
@RestController
@RequestMapping("/cus/aftersale")
@Validated
@Api(tags = "小程序申请售后退款接口")
public class WxMallAftersaleController {

    private final Log logger = LogFactory.getLog(WxMallAftersaleController.class);

    @Autowired
    private IMallAftersaleService aftersaleService;
    @Autowired
    private IMallOrderService orderService;
    @Autowired
    private IMallOrderGoodsService orderGoodsService;
    @Resource
    private ITjCustomerService customerService;

    /**
     * 售后列表
     * 售后状态，0是可申请，1是用户已申请，2是管理员审核通过，3是管理员退款成功，4是管理员审核拒绝，5是用户已取消
     * @return 售后列表
     */
    @GetMapping("/list")
    @ApiOperation(value = "小程序申请售后列表接口")
    public AjaxResult list(Long status){
        Wxuser wxuser = UserHoder.getWxuser();
        if (null == wxuser) {
            return AjaxResult.error();
        }
        LambdaQueryWrapper<MallAftersale> wq=new LambdaQueryWrapper<>();
        wq.eq(MallAftersale::getStatus,status);
        List<MallAftersale> list = aftersaleService.list(wq);
        for (MallAftersale aftersale : list) {
            List<MallOrderGoods> orderGoodsList = orderGoodsService.list(new LambdaQueryWrapper<MallOrderGoods>()
                    .eq(MallOrderGoods::getOrderId,aftersale.getOrderId())
            );
            aftersale.setOrderGoodsList(orderGoodsList);
        }
        return AjaxResult.success(list);

    }

    /**
     * 售后详情
     *
     * @param orderId 订单ID
     * @return 售后详情
     */
    @GetMapping("/detail")
    @ApiOperation(value = "售后详情")
    public Object detail(@RequestParam String orderId) {
        MallOrder order = Optional.ofNullable(orderService.getOne(new LambdaQueryWrapper<MallOrder>()
                        .eq(MallOrder::getId,orderId)
                ,false)).orElseThrow(()-> new DataNotFoundException("订单不存在"));

        order.setOrderHandleOption(OrderConstants.build(order));
        List<MallOrderGoods> orderGoodsList = orderGoodsService.list(new LambdaQueryWrapper<MallOrderGoods>()
                .eq(MallOrderGoods::getOrderId,orderId)
        );
        order.setGoodsVoList(orderGoodsList);
        MallAftersale aftersale = aftersaleService.getOne(new LambdaQueryWrapper<MallAftersale>()
                        .eq(MallAftersale::getOrderId,orderId)
                ,false);
        Map<String, Object> data = new HashMap<String, Object>();
        data.put("aftersale", aftersale);
        data.put("order", order);
        return AjaxResult.success(data);
    }



    /**
     * 申请售后
     * @return 操作结果
     */
    @PostMapping("/submit")
    @ApiOperation(value = "申请售后")
    public AjaxResult submit(@Valid @RequestBody MallAftersale aftersaleAdd) {
        Wxuser wxuser = UserHoder.getWxuser();
        if (null == wxuser) {
            return AjaxResult.error();
        }
        MallAftersale aftersale = Convert.convert(new TypeReference<MallAftersale>() {}, aftersaleAdd);
        aftersale.setUserId(wxuser.getId());

        MallOrder order = Optional.ofNullable(orderService.getOne(new LambdaQueryWrapper<MallOrder>()
                        .eq(MallOrder::getId,aftersale.getOrderId())
                        .eq(MallOrder::getUserId,aftersale.getUserId())
                ,false)).orElseThrow(()-> new DataNotFoundException("订单不存在"));

        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isRefund()) {
            return AjaxResult.error("订单不能退款");
        }
        // 设置订单申请退款状态
        order.setOrderStatus(OrderUtil.STATUS_REFUND.longValue());

        // 订单必须完成才能进入售后流程。
        if(OrderConstants.isShipStatus(order)){
            return AjaxResult.error("订单已完成 不能申请售后");
        }
        BigDecimal amount = order.getActualPrice();
        if(aftersale.getAmount().compareTo(amount) > 0){
            return AjaxResult.error("退款金额不正确");
        }
        Integer afterStatus = order.getAftersaleStatus();
        if(afterStatus.equals(AftersaleConstant.STATUS_RECEPT) || afterStatus.equals(AftersaleConstant.STATUS_REFUND)){
            return AjaxResult.error("已申请售后");
        }
        // 如果有旧的售后记录则删除（例如用户已取消，管理员拒绝）
        aftersaleService.remove(new LambdaQueryWrapper<MallAftersale>()
                .eq(MallAftersale::getOrderId,order.getId())
                .eq(MallAftersale::getUserId,aftersale.getUserId())
        );

        TjCustomer one = customerService.getOne(new LambdaQueryWrapper<TjCustomer>().eq(TjCustomer::getCusIdcard, order.getIdCard()));
        aftersale.setCusName(one.getCusName());
        aftersale.setCusIdCard(order.getIdCard());
        aftersale.setCreateTime(new Date());
        aftersale.setStatus(Long.valueOf(AftersaleConstant.STATUS_REQUEST));
        aftersale.setAftersaleSn(aftersaleService.generateAftersaleSn(aftersale.getUserId()));
        aftersaleService.save(aftersale);

        // 订单的aftersale_status和售后记录的status是一致的。
        order.setAftersaleStatus(Integer.valueOf(AftersaleConstant.STATUS_REQUEST));
        order.setUpdateTime(new Date());
        orderService.updateById(order);

        return AjaxResult.success();
    }

    /**
     * 取消售后
     * 如果管理员还没有审核，用户可以取消自己的售后申请
     * @return 操作结果
     */
    @GetMapping("/cancel")
    @ApiOperation(value = "取消售后")
    public Object cancel(@RequestParam(value = "id") String id) {
        Wxuser wxuser = UserHoder.getWxuser();
        if (null == wxuser) {
            return AjaxResult.error();
        }

        MallAftersale aftersale = Optional.ofNullable(aftersaleService.getOne(new LambdaQueryWrapper<MallAftersale>()
                        .eq(MallAftersale::getOrderId,id)
                        .eq(MallAftersale::getUserId,wxuser.getId())
                ,false)).orElseThrow(()->new DataNotFoundException("售后数据不存在"));

        MallOrder order = orderService.getById(aftersale.getOrderId());
        // 订单必须完成才能进入售后流程。
        if(OrderConstants.isShipStatus(order)){
            return AjaxResult.error("不支持售后");
        }
        Integer afterStatus = order.getAftersaleStatus();
        if(!afterStatus.equals(Integer.valueOf(AftersaleConstant.STATUS_REQUEST))){
            return AjaxResult.error("不能取消售后");
        }

        aftersale.setStatus(Long.valueOf(AftersaleConstant.STATUS_CANCEL));
        aftersale.setUpdateTime(new Date());
        aftersaleService.updateMallAftersale(aftersale);
        // 订单的aftersale_status和售后记录的status是一致的。
        order.setAftersaleStatus(Integer.valueOf(AftersaleConstant.STATUS_CANCEL));
        order.setUpdateTime(new Date());
        order.setOrderStatus(Long.valueOf(OrderConstants.STATUS_PAY));
        orderService.updateById(order);

        return AjaxResult.success();
    }



}