package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.whyc.dto.Response;
import com.whyc.mapper.ProductBomHistoryMapper;
import com.whyc.mapper.ProductBomMapper;
import com.whyc.mapper.ProductHistoryMapper;
import com.whyc.mapper.ProductMapper;
import com.whyc.pojo.Material;
import com.whyc.pojo.Product;
import com.whyc.pojo.ProductHistory;
import com.whyc.pojo.ProductLockLog;
import com.whyc.util.ActionUtil;
import com.whyc.util.DateUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;

@Service
public class ProductHistoryService {
    @Autowired(required = false)
    private ProductHistoryMapper mapper;

    @Autowired(required = false)
    private ProductMapper productMapper;

    @Autowired(required = false)
    private ProductBomMapper productBomMapper;

    @Autowired(required = false)
    private ProductBomHistoryMapper productBomHistoryMapper;

    @Autowired
    private ProductLockLogService lockLogService;

    //产品详情查看版本信息
    public Response getProductVersion(String parentCode,String customCode) {
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("parent_code",parentCode);
        wrapper.eq("custom_code",customCode);
        wrapper.orderByDesc("version_time");
        List<ProductHistory> list=mapper.selectList(wrapper);
        return new Response().setII(1,list.size()>0,list,"返回产品版信息");
    }

    /**新增追加的版本并将原先的版本的启用设置为未启用*/
    @Transactional
    public void insertAndUpdateEnabled(ProductHistory productHistory) {
        QueryWrapper<ProductHistory> query = Wrappers.query();
        query.eq("parent_code",productHistory.getParentCode())
                .eq("custom_code",productHistory.getCustomCode()).ne("enabled",0);
        List<ProductHistory> productNoZeroList = mapper.selectList(query);
        //添加新增日志到tb_product_lock_log表
        List<ProductLockLog> lockLogs = new LinkedList<>();
        for (ProductHistory historyNoZero : productNoZeroList) {
            ProductLockLog lockLog = new ProductLockLog();
            lockLog.setParentCode(historyNoZero.getParentCode());
            lockLog.setCustomCode(historyNoZero.getCustomCode());
            lockLog.setVersion(historyNoZero.getVersion());
            lockLog.setVersionTime(DateUtil.YYYY_MM_DD_HH_MM_SS.format(historyNoZero.getVersionTime()));
            if(historyNoZero.getEnabled() == 1) {
                lockLog.setReason("产品bom上传,原生效版本锁定");
            }else{
                lockLog.setReason("产品bom上传,原待审核版本锁定");
            }
            lockLog.setOwner(ActionUtil.getUser().getName());
            lockLog.setCreateTime(new Date());
            //1代表日志类型为:锁定
            lockLog.setLockFlag(1);

            lockLogs.add(lockLog);
        }
        if(lockLogs.size()>0) {
            lockLogService.insertBatch(lockLogs);
        }
        UpdateWrapper<ProductHistory> update = Wrappers.update();
        update.set("enabled",0).eq("parent_code",productHistory.getParentCode())
                .eq("custom_code",productHistory.getCustomCode()).ne("enabled",0);
        mapper.update(null,update);

        mapper.insert(productHistory);
    }

    public void updateEnabledStatus(String parentCode, String customCode, int status) {
        int anotherStatus = 0;
        if(status==0){
            anotherStatus=1;
        }else{
            anotherStatus=0;
        }
        UpdateWrapper<ProductHistory> update = Wrappers.update();
        update.set("enabled",status).eq("parent_code",parentCode)
                .eq("custom_code",customCode).eq("enabled",anotherStatus);
        mapper.update(null,update);
    }

    public ProductHistory getEnabledByParentCodeAndCustomCode(String parentCode, String customCode) {
        QueryWrapper<ProductHistory> query = Wrappers.query();
        query.eq("parent_code",parentCode).eq("custom_code",customCode).eq("enabled",1)
                .last(" limit 1");
        return mapper.selectOne(query);
    }

    public ProductHistory getLatestVersion(String parentCode, String customCode) {
        QueryWrapper<ProductHistory> query = Wrappers.query();
        query.eq("parent_code",parentCode).eq("custom_code",customCode).orderByDesc("version").last(" limit 1");
        return mapper.selectOne(query);
    }
    //历史版本可用性设定<产品中包含钣金件（0120）如果包含需要把当成产品的钣金件锁掉
    @Transactional
    public Response setpHistoryEnable(String parentCode, String customCode, int version, int enabled, String reason, String versionTime) {
        int flag=0;
        QueryWrapper qWrapper=new QueryWrapper();
        qWrapper.eq("parent_code",parentCode);
        qWrapper.eq("custom_code",customCode);
        //1.查询当前product中的信息
        Product product=productMapper.selectOne(qWrapper);
        if(enabled==1){//解锁
            //先将所有的锁定
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.eq("parent_code",parentCode);
            wrapper.eq("custom_code",customCode);
            wrapper.set("enabled",0);
            mapper.update(null,wrapper);
            //再将选中的设为可用(查出要使用版本)
            QueryWrapper hisWrapper=new QueryWrapper();
            hisWrapper.eq("parent_code",parentCode);
            hisWrapper.eq("custom_code",customCode);
            hisWrapper.eq("version",version);
            ProductHistory his=mapper.selectOne(hisWrapper);
            UpdateWrapper wrapper1=new UpdateWrapper();
            wrapper1.eq("parent_code",parentCode);
            wrapper1.eq("custom_code",customCode);
            wrapper1.eq("id",his.getId());
            wrapper1.set("enabled",1);
            flag=mapper.update(null,wrapper1);
            if(flag>0){
                //2.将选中的版本的历史信息查询出来
                /*qWrapper.eq("id",his.getId());
                ProductHistory pHistory=mapper.selectOne(qWrapper);*/
                //3:prodcut中删除旧的产品信息
                UpdateWrapper deleteWrapper=new UpdateWrapper();
                deleteWrapper.eq("id",product.getId());
                productMapper.delete(deleteWrapper);
                //4.productBom中删除旧的信息
                if(product!=null){
                    UpdateWrapper bomWrapper=new UpdateWrapper();
                    bomWrapper.eq("product_id",product.getId());
                    productBomMapper.delete(bomWrapper);
                }
                if(his!=null){
                    // 5.在product中插入设定可用的pHistory
                    productMapper.insertPselectPH(his.getId());
                    //6.在productBom中插入pHsitoryBom查询出的数据
                    productBomMapper.insertBomSelectBomH(his.getId(),his.getSubVersionMax());
                }
            }
        }else{
            UpdateWrapper wrapper=new UpdateWrapper();
            wrapper.eq("parent_code",parentCode);
            wrapper.eq("custom_code",customCode);
            wrapper.eq("version",version);
            wrapper.set("enabled",0);
            flag=mapper.update(null,wrapper);

            //3:prodcut中产品版本设置为-1
            UpdateWrapper uWrapper=new UpdateWrapper();
            uWrapper.eq("parent_code",parentCode);
            uWrapper.eq("custom_code",customCode);
            //设为不可用版本为-1
            uWrapper.set("version",-1);
            productMapper.update(null,uWrapper);

            //4.查询产品是否存在物料时钣金件的产品
            List<Material> list=productMapper.selectMaterial_0120(parentCode,customCode);
            //如果存在则锁定
            if(list!=null&&list.size()>0){
                for (Material material_0120:list) {
                    //先锁定历史
                    UpdateWrapper wrapperHistory_0120=new UpdateWrapper();
                    wrapperHistory_0120.eq("parent_code",material_0120.getSubCode());
                    wrapperHistory_0120.set("enabled",0);
                    mapper.update(null,wrapperHistory_0120);
                    //再设置实时为-1
                    UpdateWrapper wrapper_0120=new UpdateWrapper();
                    wrapper_0120.eq("parent_code",material_0120.getSubCode());
                    //设为不可用版本为-1
                    wrapper_0120.set("version",-1);
                    productMapper.update(null,wrapper_0120);
                }
            }

        }
        //锁定和解锁记录添加
        if(flag>0){ //操作成功
            ProductLockLog lockLog = new ProductLockLog();
            lockLog.setParentCode(parentCode);
            lockLog.setCustomCode(customCode);
            lockLog.setVersion(version);
            lockLog.setVersionTime(versionTime);
            lockLog.setReason(reason);
            lockLog.setOwner(ActionUtil.getUser().getName());
            lockLog.setCreateTime(new Date());
            if(enabled==0){ //锁定
                lockLog.setLockFlag(1);
            }else{ //解锁
                lockLog.setLockFlag(0);
            }
            lockLogService.insert(lockLog);
        }
        return new Response().set(1,flag>0,"历史版本可用性设定");
    }

    public void insert(ProductHistory his) {
        mapper.insert(his);
    }

    /**
     *  获取标准产品
     * @param parentCode
     * @return
     */
    public ProductHistory getStandard(String parentCode) {
        QueryWrapper<ProductHistory> query = Wrappers.query();
        query.eq("parent_code",parentCode);
        List<ProductHistory> historyList = mapper.selectList(query);
        for (ProductHistory history : historyList) {
            String customCode = history.getCustomCode();
            if(customCode == null || customCode.trim().equals("")){ //不存在定制表单号,是标准产品
                return history;
            }
        }
        return null;
    }

    public boolean checkExists(String parentCode, String customCode) {
        QueryWrapper<ProductHistory> query = Wrappers.query();
        query.eq("parent_code",parentCode);
        if(!StringUtils.isBlank(customCode)){ //标准产品
            query.eq("custom_code",customCode);
        }
        query.last(" limit 1");
        ProductHistory productHistory = mapper.selectOne(query);
        return productHistory!=null;
    }

    public ProductHistory getById(Integer id) {
        return mapper.selectById(id);
    }
}