package com.glxp.api.service.collect;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.dao.basic.BasicProductsDao;
import com.glxp.api.dao.basic.SysWorkplaceDocumentDao;
import com.glxp.api.dao.basic.UdiRelevanceDao;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.collect.IoCollectOrder;
import com.glxp.api.entity.collect.IoCollectOrderBiz;
import com.glxp.api.entity.collect.IoCollectOrderBizOrigin;
import com.glxp.api.entity.collect.IoCollectOrderOrigin;
import com.glxp.api.exception.JsonException;
import com.glxp.api.http.ErpBasicClient;
import com.glxp.api.req.basic.GetSickPrescribeRequest;
import com.glxp.api.req.basic.WorkBindBusTypeRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.BasicSkPrescribeResponse;
import com.glxp.api.res.basic.SysWorkplaceDocumentResponse;
import com.glxp.api.service.basic.*;
import com.glxp.api.util.BeanCopyUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 原始单据下载
 */
@Service
public class IoCollectOriginService {
    @Resource
    private ErpBasicClient erpBasicClient;
    @Resource
    private BasicSkPrescribeService basicSkPrescribeService;
    @Resource
    private BasicSkPrescirbeDetailService basicSkPrescirbeDetailService;
    @Resource
    private IoCollectOrderService ioCollectOrderService;

    @Resource
    IoCollectOrderService collectOrderService;
    @Resource
    IoCollectOrderBizService collectOrderBizService;
    @Resource
    private DownloadFactory downloadFactory;
    @Resource
    private SysWorkplaceDocumentDao sysWorkplaceDocumentDao;
    @Resource
    private SysWorkplaceDocumentService sysWorkplaceDocumentService;
    @Resource
    private IoCollectOrderOriginService collectOrderOriginService;
    @Resource
    private IoCollectOrderBizOriginService collectOrderBizOriginService;
    @Resource
    private UdiRelevanceDao udiRelevanceDao;
    @Resource
    private BasicProductsDao basicProductsDao;

    public BaseResponse downloadOrderV2(CollectOrderRequest collectOrderRequest) {
        //条件
        String busType = collectOrderRequest.getBusType();
        if (StrUtil.isBlank(busType)) {
            //下载工位下的类型
            List<SysWorkplaceDocumentEntity> list = sysWorkplaceDocumentService.list();
            if (CollUtil.isNotEmpty(list)) {
                for (SysWorkplaceDocumentEntity item : list) {
                    collectOrderRequest.setBusType(item.getDocumentTypeCode());
                    downloadFactory.downloadOrder(collectOrderRequest);
                }
            } else {
                return ResultVOUtils.error("未配置业务类型");
            }
            return ResultVOUtils.success("下载成功");
        } else {
            return downloadFactory.downloadOrder(collectOrderRequest);
        }

    }


    /**
     * 异常处理
     *
     * @param collectOrderRequest
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse errorHandle(CollectOrderRequest collectOrderRequest) {
        if (StrUtil.isBlank(collectOrderRequest.getBillNo())) {
            throw new JsonException(500, "单据号不能为空");
        }
        if (collectOrderRequest.getTagStatus() != 4) {
            throw new JsonException(500, "非异常单据，无需处理");
        }
        if (StrUtil.isBlank(collectOrderRequest.getBusType())) {
            throw new JsonException(500, "单据类型不能为空");
        }
        //删除异常单据
        collectOrderBizService.remove(new LambdaQueryWrapper<IoCollectOrderBiz>()
                .eq(IoCollectOrderBiz::getOrderIdFk, collectOrderRequest.getBillNo()));
        collectOrderService.remove(new LambdaQueryWrapper<IoCollectOrder>()
                .eq(IoCollectOrder::getBillNo, collectOrderRequest.getBillNo())
                .eq(IoCollectOrder::getTagStatus, 4));
        //重新拉取
        return this.downloadOrderV2(collectOrderRequest);
    }

    @Transactional(rollbackFor = Exception.class)
    public BaseResponse errorHandleSubmit(CollectOrderRequest collectOrderRequest) {
        if (StrUtil.isBlank(collectOrderRequest.getBillNo())) {
            throw new JsonException(500, "单据号不能为空");
        }
        if (collectOrderRequest.getTagStatus() != 4) {
            throw new JsonException(500, "非异常单据，无需处理");
        }
        if (StrUtil.isBlank(collectOrderRequest.getBusType())) {
            throw new JsonException(500, "单据类型不能为空");
        }
        String billNo = collectOrderRequest.getBillNo();
        List<IoCollectOrderOrigin> thrOrderEntities = collectOrderOriginService.list(new LambdaUpdateWrapper<IoCollectOrderOrigin>().eq(IoCollectOrderOrigin::getBillNo, billNo));

        List<IoCollectOrder> ioCollectOrderList = new ArrayList<>();
        if (CollUtil.isNotEmpty(thrOrderEntities)) {
            for (IoCollectOrderOrigin thrOrder : thrOrderEntities) {
                IoCollectOrder ioCollectOrder = new IoCollectOrder();
                BeanUtil.copyProperties(thrOrder, ioCollectOrder);
                StringBuilder errorMsg = new StringBuilder();
                List<IoCollectOrderBiz> bizList = new ArrayList<>();

                List<IoCollectOrderBizOrigin> list = collectOrderBizOriginService.list(new LambdaUpdateWrapper<IoCollectOrderBizOrigin>().eq(IoCollectOrderBizOrigin::getOrderIdFk, thrOrder.getBillNo()));
                for (IoCollectOrderBizOrigin entity : list) {
                    IoCollectOrderBiz collectOrderBiz = new IoCollectOrderBiz();
                    BeanUtil.copyProperties(entity, collectOrderBiz);
                    UdiRelevanceEntity basicUdirelEntity = udiRelevanceDao.selectOne(new LambdaQueryWrapper<UdiRelevanceEntity>().eq(UdiRelevanceEntity::getMainId, entity.getThrCode()));
                    if (basicUdirelEntity != null) {
                        collectOrderBiz.setRelId(basicUdirelEntity.getId());
                        BasicProductsEntity basicProductsEntity = basicProductsDao.selectOne(new LambdaQueryWrapper<BasicProductsEntity>().eq(BasicProductsEntity::getUuid, basicUdirelEntity.getUuid()).last("limit 1"));
                        if (StrUtil.isEmpty(basicProductsEntity.getNameCode())) {
                            errorMsg.append(entity.getCpmctymc()).append("字典未对照").append(";");
                        }
                    } else {
                        errorMsg.append(entity.getCpmctymc()).append("字典未对照").append(";");
                    }
                    collectOrderBiz.setTagStatus(1);
                    collectOrderBiz.setUnTagCount(0);
                    bizList.add(collectOrderBiz);
                }
                if (StrUtil.isNotBlank(errorMsg)) {
                    thrOrder.setTagStatus(4);
                    thrOrder.setErrorMsg(errorMsg.toString());
                    collectOrderOriginService.updateById(thrOrder);

                    List<IoCollectOrderBizOrigin> ioCollectOrderBizOrigins = BeanCopyUtils.copyList(bizList, IoCollectOrderBizOrigin.class);
                    collectOrderBizOriginService.updateBatchById(ioCollectOrderBizOrigins);
                }else {
                    thrOrder.setTagStatus(0);
                    collectOrderOriginService.updateById(thrOrder);

                    List<IoCollectOrderBizOrigin> ioCollectOrderBizOrigins = BeanCopyUtils.copyList(bizList, IoCollectOrderBizOrigin.class);
                    collectOrderBizOriginService.updateBatchById(ioCollectOrderBizOrigins);

                    collectOrderBizService.saveBatch(bizList);
                    ioCollectOrder.setFromType("HIS系统");
                    ioCollectOrder.setWorkPlaceCode(collectOrderRequest.getWorkPlaceCode());
                    ioCollectOrder.setCreateTime(new Date());
                    ioCollectOrder.setCreateUser(collectOrderRequest.getCreateUser());
                    ioCollectOrder.setBackupOrderRemark1(null);
                    ioCollectOrder.setUpdateTime(new Date());
                    ioCollectOrder.setSplitStatus(0);
                    ioCollectOrder.setTagStatus(0);

                    collectOrderService.save(ioCollectOrder);
                }
            }

        }
        return ResultVOUtils.success("提交成功");
    }
}