package com.fdkankan.sale.service.impl;
import java.util.*;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.sale.common.PageInfo;
import com.fdkankan.sale.common.RepairStatusEnum;
import com.fdkankan.sale.common.ResultCode;
import com.fdkankan.sale.entity.*;
import com.fdkankan.sale.exception.BusinessException;
import com.fdkankan.sale.mapper.IRepairMapper;
import com.fdkankan.sale.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.sale.util.DateUtil;
import com.fdkankan.sale.util.StatusUtil;
import com.fdkankan.sale.vo.request.*;
import com.fdkankan.sale.vo.response.RepairRegisterPartVo;
import com.fdkankan.sale.vo.response.RepairerVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-12-12
 */
@Service
public class RepairServiceImpl extends ServiceImpl<IRepairMapper, Repair> implements IRepairService {

    @Autowired
    IRepairLogService repairLogService;
    @Autowired
    ISysUserService sysUserService;
    @Autowired
    IRepairPayService repairPayService;
    @Autowired
    IRepairFaultService repairFaultService;
    @Autowired
    IPriceListService priceListService;
    @Autowired
    RepairSupplyService repairSupplyService;
    @Autowired
    IRepairService repairService;

    @Override
    public void updateRepairStatus(String repairId, Integer status) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getStatus,status);
        this.update(wrapper);
    }

    @Override
    public Page<RepairerVo> saleOrderList(RepairParam param) {
        return this.getBaseMapper().saleOrderList(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }

    @Override
    public Page<RepairerVo> supplyOrderList( RepairParam param) {
        return this.getBaseMapper().supplyOrderList(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }

    @Override
    public Page<RepairerVo> u8List( RepairParam param) {
        return this.getBaseMapper().u8List(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }

    @Override
    public Page<RepairerVo> checkAccountList( RepairParam param) {
        return this.getBaseMapper().checkAccountList(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }

    @Override
    public Page<RepairerVo> repairerOrderList(RepairParam param) {
        return this.getBaseMapper().repairerOrderList(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }

    @Override
    public Page<RepairerVo> testOrderList(RepairParam param) {
        return this.getBaseMapper().testOrderList(new Page<>(param.getPageNum(),param.getPageSize()),param);
    }


    @Override
    public void paySuccess(String orderSn, String tradeNo, String openid) {
        RepairPay repairPay = repairPayService.getByOrderSn(orderSn);
        if(repairPay == null){
            return;
        }
        Repair repair = repairService.getById(repairPay.getRepairId());
        if(repair == null){
            return;
        }
        repairPayService.updatePayStatus(orderSn,tradeNo,openid);
        if(orderSn.contains("se_s")){
            List<RepairRegisterPartVo> partVoList = repairSupplyService.partInfo(repairPay.getRepairId(), 1);
            if(partVoList.size() >0){
                repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_RECOVERED.status(),repair.getStatus(),"完成维修支付成功");
            }else {
                repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_SHIPPED.status(),repair.getStatus(),"完成维修支付成功");
            }
        }
        if(orderSn.contains("se_c")){
            List<RepairRegisterPartVo> partVoList = repairSupplyService.partInfo(repairPay.getRepairId(), 1);
            if(partVoList.size() >0){
                repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_CANCELED_RECOVERED.status(),repair.getStatus(),"取消维修支付成功");
            }else {
                repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_SHIPPED.status(),repair.getStatus(),"取消维修支付成功");
            }
        }
    }

    @Override
    public void updateCommentStatus(String repairId) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getCommentStatus,1);
        this.update(wrapper);
    }

    @Override
    public void updateInvoiceStatus(String repairId) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getInvoiceStatus,1);
        this.update(wrapper);
    }

    @Override
    public Page<RepairerVo> pageInfoList(RepairInfoListParam param) {
        if(param.getFaultId() != null){
            List<RepairFault> list = repairFaultService.getByFaultId(param.getFaultId());
            if(list.size() >0){
                Set<String> repairIds = list.stream().map(RepairFault::getRepairId).collect(Collectors.toSet());
                param.setRepairIds(repairIds);
            }else {
                Set<String> repairIds = new HashSet<>();
                repairIds.add("empty");
                param.setRepairIds(repairIds);
            }
        }
        Page<RepairerVo> page = getBaseMapper().pageInfoList(new Page<>(param.getPageNum(), param.getPageSize()), param);
        sysUserService.setSaleNameAndRepairManName(page.getRecords());
        return page;
    }

    @Override
    public List<Repair> getBySnCode(String snCode) {
        LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Repair::getCameraSnCode,snCode);
        wrapper.orderByDesc(Repair::getCreateTime);
        return this.list(wrapper);
    }

    @Override
    public String getLastRepairId(Repair repair) {

        LambdaQueryWrapper<Repair> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Repair::getCameraSnCode,repair.getCameraSnCode());
        wrapper.lt(Repair::getCreateTime,repair.getCreateTime());
        wrapper.notIn(Repair::getRepairId,Arrays.asList(repair.getRepairId()));
        wrapper.orderByAsc(Repair::getCreateTime);
        List<Repair> list  =  this.list(wrapper);
        if(list.isEmpty()){
            return null;
        }
        return list.get(0).getRepairId();
    }

    @Override
    public void updateWarrantyType(String repairId, Integer warrantyType) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getWarrantyType,warrantyType);
        this.update(wrapper);
    }

    @Override
    public void updateCancelStatus(String repairId, Integer status,String cancelRemark) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getCancelStatus,status);
        wrapper.set(Repair::getCancelRemark,cancelRemark);
        this.update(wrapper);
    }

    @Override
    public void updateRepairInvoiceStatus(String repairId, Integer InvoiceStatus) {
        LambdaUpdateWrapper<Repair> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Repair::getRepairId,repairId);
        wrapper.set(Repair::getInvoiceStatus,InvoiceStatus);
        this.update(wrapper);
    }
}