package com.glxp.api.service.collect;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.collect.IoCollectOrderBackupMapper;
import com.glxp.api.dao.inout.IoCodeTempDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.CompanyProductRelevanceEntity;
import com.glxp.api.entity.basic.SysWorkplaceDocumentEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.http.ErpBasicClient;
import com.glxp.api.http.sync.SpGetHttpClient;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.req.collect.PostCollectOrderRequest;
import com.glxp.api.res.basic.BasicSkPrescribeResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.basic.SysWorkplaceDocumentService;
import com.glxp.api.service.basic.UdiRlSupService;
import com.glxp.api.service.inout.IoAddInoutService;
import com.glxp.api.service.inout.IoCheckInoutService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

@Service
public class IoCollectOrderBackupService extends ServiceImpl<IoCollectOrderBackupMapper, IoCollectOrderBackup> {

    @Resource
    IoCollectOrderBackupMapper ioCollectOrderBackupMapper;
    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;

    @Resource
    IoCollectOrderCodeAutoService collectOrderCodeAutoService;

    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;

    @Resource
    SysWorkplaceDocumentService sysWorkplaceDocumentService;

    @Resource
    IBasicBussinessTypeService bussinessTypeService;
    @Resource
    private GennerOrderUtils gennerOrderUtils;
    @Resource
    IoOrderService orderService;
    @Resource
    private IoCodeTempDao codesTempDao;

    @Resource
    IoAddInoutService addInoutService;

    @Resource
    @Lazy
    IoCheckInoutService ioCheckInoutService;

    @Resource
    private ErpBasicClient erpBasicClient;

    @Resource
    private SpGetHttpClient spGetHttpClient;


    public List<IoCollectOrderResponse> filterList(CollectOrderRequest collectOrderRequest) {
        if (collectOrderRequest == null) {
            return Collections.emptyList();
        }
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }
        List<IoCollectOrderResponse> data = ioCollectOrderBackupMapper.filterList(collectOrderRequest);
        return data;
    }

    public IoCollectOrderBackup getByBillNo(String billNo) {
        return ioCollectOrderBackupMapper.selectOne(new LambdaQueryWrapper<IoCollectOrderBackup>().eq(IoCollectOrderBackup::getBillNo, billNo).last("limit 1"));
    }

    public int updateByBillNo(IoCollectOrderBackup collectOrder) {
        return ioCollectOrderBackupMapper.update(collectOrder, new UpdateWrapper<IoCollectOrderBackup>().eq("billNo", collectOrder.getBillNo()));
    }

    public List<CollectOrderBizResponse> combieOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
        List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.filterList(collectOrderBizRequest);

        List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), null);
//        List<IoCollectOrderCodeAuto> unSplitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 2);
        List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.listByBillNo(collectOrderBizRequest.getOrderIdFk());

        List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
        for (CollectOrderBizResponse collectOrderBiz : list) {
            CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
            BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);
            //查询自动赋码的code
            for (IoCollectOrderCodeAuto collectOrderCodeAuto : splitCodes) {
                if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
                }
            }
            //查询手动赋码的code
            for (IoCollectOrderCodeMan collectOrderCodeMan : manList) {
                if (IntUtil.value(collectOrderCodeMan.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + collectOrderCodeMan.getUdiCode());
                }
            }
            if (StrUtil.isNotEmpty(collectOrderBizResponse.getReplaceCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getReplaceCode());
            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode());
            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getSplitUdiCode());
            }

            collectOrderBizResponses.add(collectOrderBizResponse);
        }
        return collectOrderBizResponses;
    }


    @Transactional(rollbackFor = Exception.class)
    public void generateOrder(String billNo) {

        IoCollectOrderBackup collectOrder = getByBillNo(billNo);
        SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        //1.内部系统，且单据为扫码生成业务单则创建系统单据
        if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
            List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
            BasicBussinessTypeEntity bussinessTypeEntity;
            sysWorkplaceDocumentEntity.getInoutType();

            //构造单据数据
            IoOrderEntity orderEntity = new IoOrderEntity();
            bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode());
            orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
            orderEntity.setAction(bussinessTypeEntity.getAction());
            orderEntity.setCreateTime(new Date());
            orderEntity.setInvCode(sysWorkplaceDocumentEntity.getInvCode() + "");
            orderEntity.setDeptCode("");
            orderEntity.setFromCorp(collectOrder.getFromCorp());
            orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
            orderEntity.setExportStatus(0);
            orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
            orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
            orderEntity.setCreateUser(collectOrder.getCreateUser());
            orderEntity.setCreateTime(new Date());
            orderEntity.setUpdateUser(collectOrder.getCreateUser());
            orderEntity.setUpdateTime(new Date());
            orderEntity.setCustomerId("110");
            orderEntity.setOrderType(2);
            orderEntity.setFromType(2);
            String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
            orderEntity.setBillNo(orderNo);
            List<IoCodeTempEntity> lossCodesList = new ArrayList<>();

            for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
                lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
            }
            orderService.insertOrder(orderEntity);
            codesTempDao.insertBatch(lossCodesList);
            addInoutService.dealProcess(orderEntity);
            if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
                ioCheckInoutService.check(orderEntity.getBillNo());
            }
        } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
            //更新单据为已完成
            IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
            orderEntity.setStatus(7);
            orderEntity.setFromType(2);
            orderEntity.setDealStatus(3);
            orderEntity.setAuditTime(new Date());
            orderService.update(orderEntity);
            //推送自助平台
            spGetHttpClient.updateCheckStatus(orderEntity, collectOrder.getCreateUser());
        } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 0) {
            //todo  根据单据类型上传医保或者第三方系统
            PostCollectOrderRequest orderRequest = new PostCollectOrderRequest();
            orderRequest.setThirdSys("thirdId");
            CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
            collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo());
            List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest);
            collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses);
            List<IoCollectOrderBackup> collectOrderList = new ArrayList<>();
            collectOrderList.add(collectOrder);
            orderRequest.setCollectOrderList(collectOrderList);
            BaseResponse<BasicSkPrescribeResponse> baseResponse = erpBasicClient.postOrder(orderRequest);
            log.debug("单据返回=========" + baseResponse);
            if (baseResponse.getCode() == 20000) {
                //
            } else {
                throw new JsonException("连接第三方系统接口服务出错，" + baseResponse.getMessage());
            }

        }
//        //插入处方备份表
//        IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
//        BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
//        boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup);
//        if (!save){
//            throw new JsonException(500,"处方备用上传失败");
//        }
//        List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
//        for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){
//            IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
//            BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
//            boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup);
//            if (!save1){
//                throw new JsonException(500,"处方备用明细上传失败");
//            }
//        }
    }

    @Resource
    UdiRlSupService udiRlSupService;

    private IoCodeTempEntity buildCodeEntity(IoCollectOrderCodeMan collectOrderCodeMan, IoOrderEntity orderEntity) {
        IoCodeTempEntity tempEntity = new IoCodeTempEntity();
        tempEntity.setOrderId(orderEntity.getBillNo());
        tempEntity.setCode(collectOrderCodeMan.getUdiCode());
        tempEntity.setRelId(collectOrderCodeMan.getRelId());
        tempEntity.setMainAction(orderEntity.getMainAction());
        tempEntity.setInvCode(orderEntity.getInvCode());
        tempEntity.setBatchNo(collectOrderCodeMan.getBatchNo());
        tempEntity.setProduceDate(collectOrderCodeMan.getProductDate());
        tempEntity.setExpireDate(collectOrderCodeMan.getExpireDate());
        tempEntity.setSerialNo(collectOrderCodeMan.getSerialNo());
        tempEntity.setNameCode(collectOrderCodeMan.getNameCode());
        tempEntity.setCount(collectOrderCodeMan.getScanCount());
        tempEntity.setReCount(collectOrderCodeMan.getScanCount());
        tempEntity.setCreateTime(new Date());
        tempEntity.setUpdateTime(new Date());
        CompanyProductRelevanceEntity udiRlSupEntity = udiRlSupService.selOneByRlId(tempEntity.getRelId());
        if (udiRlSupEntity != null)
            tempEntity.setSupId(udiRlSupEntity.getCustomerId());
        tempEntity.setDeptCode(orderEntity.getDeptCode());
        return tempEntity;
    }


    @Transactional(rollbackFor = Exception.class)
    public Boolean orderUpload(String billNo) {
        IoCollectOrderBackup updateOrder = new IoCollectOrderBackup();
        updateOrder.setBillNo(billNo);
        try {
            this.generateOrder(billNo);
            updateOrder.setUploadStatus(2);
        } catch (Exception e) {
            updateOrder.setUploadStatus(3);
            updateOrder.setUploadError(e.getMessage());
        }
        //更新状态
        this.updateByBillNo(updateOrder);
        if (updateOrder.getUploadStatus() == 3) {
            return false;
        }
        return true;
    }

    public List<IoCollectOrderCodeMan> codeDetail(Integer bizIdFk) {
        List<IoCollectOrderCodeMan> reList = new ArrayList<>();

        List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.list(new LambdaQueryWrapper<IoCollectOrderCodeAuto>().eq(IoCollectOrderCodeAuto::getBizIdFk,bizIdFk));
        List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.list(new LambdaQueryWrapper<IoCollectOrderCodeMan>().eq(IoCollectOrderCodeMan::getBizIdFk,bizIdFk));

        if (CollUtil.isNotEmpty(splitCodes)){
            splitCodes.forEach( item -> {
                IoCollectOrderCodeMan ioCollectOrderCodeMan = new IoCollectOrderCodeMan();
                BeanUtils.copyProperties(item,ioCollectOrderCodeMan);
                reList.add(ioCollectOrderCodeMan);
            });
        }

        if (CollUtil.isNotEmpty(manList)){
            manList.forEach( item -> {
                reList.add(item);
            });
        }
        return reList;
    }
}