package com.glxp.api.service.inout;

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.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.inout.IoCodeTempDao;
import com.glxp.api.dao.system.CompanyDao;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.collect.RelCodeDetail;
import com.glxp.api.entity.inout.IoCodeLostEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.purchase.SupCertEntity;
import com.glxp.api.entity.purchase.SupProductEntity;
import com.glxp.api.entity.system.CompanyEntity;
import com.glxp.api.req.alihealth.AlihealthYljgCodedetailReqeust;
import com.glxp.api.req.inout.AddOrderRequest;
import com.glxp.api.req.inout.FilterCodeRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.RelCodeDetailResponse;
import com.glxp.api.res.inout.AddCodeResult;
import com.glxp.api.res.inout.IoCodeResponse;
import com.glxp.api.res.inout.IoCodeTempResponse;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.RelCodeDetailService;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.util.BeanCopyUtils;
import com.glxp.api.util.DateUtil;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import com.glxp.api.util.alihealth.AlihealthYljgUtils;
import com.glxp.api.util.page.PageQuery;
import com.glxp.api.util.page.TableDataInfo;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.util.udi.UdiCalCountUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.BeanUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Transactional(rollbackFor = Exception.class)
@Slf4j
public class IoCodeTempService {

    @Resource
    IoCodeTempDao ioCodeTempDao;


    public IoCodeTempEntity selectById(Integer id) {
        return ioCodeTempDao.selectById(id);
    }


    public int insert(IoCodeTempEntity codeEnttity) {
        codeEnttity.setId(null);
        return ioCodeTempDao.insert(codeEnttity);
    }


    public int deleteById(Integer id) {
        return ioCodeTempDao.deleteById(id);
    }


    public boolean insertBatch(List<IoCodeTempEntity> codeEnttities) {
        return ioCodeTempDao.insertBatch(codeEnttities);
    }


    public List<IoCodeTempEntity> findByOrderId(String billNo) {
        return ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", billNo));
    }


    public List<IoCodeResponse> findJoinByOrderId(String billNo) {
        if (StrUtil.isEmpty(billNo))
            return null;
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(billNo);
        return ioCodeTempDao.filterJoinProduct(filterCodeRequest);
    }


    public int updateById(IoCodeTempEntity codeEnttity) {
        return ioCodeTempDao.updateById(codeEnttity);
    }


    public int updateByOrderId(IoCodeTempEntity codeTempEntity) {
        return ioCodeTempDao.update(codeTempEntity, new QueryWrapper<IoCodeTempEntity>().eq("orderId", codeTempEntity.getOrderId()));
    }


    public IoCodeTempEntity findByUnique(String orderId, String code) {
        List<IoCodeTempEntity> codeTempEntities = ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId).eq("code", code));
        if (CollUtil.isNotEmpty(codeTempEntities)) {
            IoCodeTempEntity codeTempEntity = codeTempEntities.get(0);
            if (codeTempEntities.size() > 1) {
                for (int i = 1; i < codeTempEntities.size(); i++) {
                    codeTempEntity.setCount(codeTempEntity.getCount() + codeTempEntities.get(i).getCount());
                    codeTempEntity.setReCount(codeTempEntity.getReCount() + codeTempEntities.get(i).getReCount());
                }
            }

            return codeTempEntity;

        }

        return null;
    }


    public TableDataInfo<IoCodeTempEntity> findByOrderId(FilterCodeRequest filterCodeRequest) {
        PageQuery pageQuery = new PageQuery();
        BeanCopyUtils.copy(filterCodeRequest, pageQuery);
        Page<IoCodeTempEntity> page = ioCodeTempDao.selectPage(pageQuery.build(), new QueryWrapper<IoCodeTempEntity>().eq("orderId", filterCodeRequest.getOrderId()));
        return TableDataInfo.build(page);
    }


    public int deleteByBillNo(String orderId) {
        return ioCodeTempDao.delete(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
    }


    public List<IoCodeTempResponse> findCodeList(FilterCodeRequest filterCodeRequest) {
        if (null != filterCodeRequest && null != filterCodeRequest.getPage() && null != filterCodeRequest.getLimit()) {
            PageHelper.offsetPage((filterCodeRequest.getPage() - 1) * filterCodeRequest.getLimit(), filterCodeRequest.getLimit());
        }
        return ioCodeTempDao.selectCodeList(filterCodeRequest);
    }


    public boolean isExit(String orderId) {
        return ioCodeTempDao.exists(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
    }


    public Integer selectExitCount(String orderId, String bacthNo, Long relId, String supId) {
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(orderId);
        filterCodeRequest.setBatchNo(bacthNo);
        filterCodeRequest.setRelId(relId + "");
        filterCodeRequest.setSupId(supId);
        return ioCodeTempDao.selectExitCount(filterCodeRequest);
    }


    public Integer selectExitCount(String orderId, String code) {
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(orderId);
        filterCodeRequest.setCode(code);
        return ioCodeTempDao.selectExitCount(filterCodeRequest);
    }


    public Boolean checkTempCode(IoCodeTempEntity ioCodeTempEntity) {

        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("code", ioCodeTempEntity.getCode());
        ew.eq("corpOrderId", ioCodeTempEntity.getCorpOrderId());
        ew.eq("batchNo", ioCodeTempEntity.getBatchNo());
        ew.eq("produceDate", ioCodeTempEntity.getProduceDate());
        ew.eq("expireDate", ioCodeTempEntity.getExpireDate());
        ew.eq("serialNo", ioCodeTempEntity.getSerialNo());
        Long count = ioCodeTempDao.selectCount(ew);
        if (count > 0) {
            return false;
        }
        return true;
    }


    public IoCodeTempEntity selectByCode(String code, String batchNo, String action) {
        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("code", code);
        ew.eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo);
        ew.eq(StrUtil.isNotEmpty(action), "action", action);
        return ioCodeTempDao.selectOne(ew);
    }


    public List<IoCodeTempEntity> selectByCodes(List<String> codeList, String orderId) {
        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("orderId", orderId);
        ew.in("code", codeList);
        return ioCodeTempDao.selectList(ew);
    }


    @Resource
    private IoOrderService orderService;
    @Resource
    private IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    UdiCalCountUtil udiCalCountUtil;
    @Resource
    IoOrderDetailCodeService ioOrderDetailCodeService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;


    public Boolean removeCodeById(IoCodeTempEntity codeTempEntity) {

        IoOrderEntity orderEntity = orderService.findByBillNo(codeTempEntity.getOrderId());
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        UdiRelevanceResponse udiRelevanceResponses = udiRelevanceService.selectByNameCode(codeTempEntity.getNameCode());

        if (codeTempEntity.getMyCount() > 1) {
            codeTempEntity.setCount(codeTempEntity.getMyCount() - 1);
            if (bussinessTypeEntity.isUse()) {
                codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
            } else {
                codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
            }
            updateById(codeTempEntity);
        } else {
            deleteById(codeTempEntity.getId());
        }

        //更新扫码详情
        IoOrderDetailCodeEntity orderDetailCodeEntity = ioOrderDetailCodeService.findByUnique(orderEntity.getBillNo(), codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getPrice());
        if (orderDetailCodeEntity != null) {
            //扫码数量-1
            int orderCount = IntUtil.value(orderDetailCodeEntity.getCount());
            int orderReCount = IntUtil.value(orderDetailCodeEntity.getReCount());
            if (orderCount > 1) {
                orderDetailCodeEntity.setCount(orderCount - 1);


                if (bussinessTypeEntity.isUse()) {
                    orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
//                    codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses);
                } else {
                    orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
//                    codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses);
                }

                ioOrderDetailCodeService.update(orderDetailCodeEntity);
            } else {
                ioOrderDetailCodeService.deleteById(orderDetailCodeEntity.getId());
            }
        }


        boolean r1 = orderDetailBizService.isExit(orderEntity.getBillNo());
        boolean r2 = ioOrderDetailCodeService.isExit(orderEntity.getBillNo());
        if (!r1 && !r2) {
            if (StrUtil.isNotEmpty(orderDetailCodeEntity.getOrderIdFk()))
                orderService.deleteByBillNo(orderDetailCodeEntity.getOrderIdFk());
        }

        orderEntity.setUpdateTime(new Date());
        orderService.update(orderEntity);
        return true;
    }


    @Resource
    RelCodeDetailService relCodeDetailService;

    public boolean ieExitRel(String code, String orderId) {
        boolean ret = false;
        RelCodeDetailResponse relCodeDetail = relCodeDetailService.findByCode(code);
        if (relCodeDetail != null) {
            //判断是否存在关联关系：1.先判断当前单号是否存在父码，若存在则表示存在关联关系重复扫码
            if (StrUtil.isNotEmpty(relCodeDetail.getParentCode())) {
                ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
                if (!ret) {
                    relCodeDetail = relCodeDetailService.findByCode(relCodeDetail.getParentCode());
                    ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
                }
            }
            if (ret)
                return true;
            //若父码不存在，判断当前单号是否存在当前码的子码，若存在则表示存在关联关系重复扫码
            ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getParentCode, code));
            if (!ret) {
                ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getGrantPaCode, code));
            }
        }
        return ret;
    }


    @Resource
    IoCodeService ioCodeService;

    public BaseResponse findCodes(FilterCodeRequest filterCodeRequest) {
        List<IoCodeResponse> ioCodeResponses = ioCodeService.filterList(filterCodeRequest);
        PageInfo<IoCodeResponse> pageInfo = new PageInfo<>(ioCodeResponses);
        PageSimpleResponse<IoCodeResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(pageInfo.getList());
//        ArrayList<IoCodeTempResponse> ioCodeTempResponses = new ArrayList<>();
//        ioCodeTempResponses.addAll(ioCodeResponses.stream()
//                .map(ioCodeResponse -> convertToIoCodeTempResponse(ioCodeResponse))
//                .collect(Collectors.toList()));
        return ResultVOUtils.success(pageSimpleResponse);
    }

//    public IoCodeTempResponse convertToIoCodeTempResponse(IoCodeResponse response) {
//        IoCodeTempResponse tempResponse = new IoCodeTempResponse();
//        BeanUtils.copyProperties(response,tempResponse);
//        return tempResponse;
//    }
}