package com.doumee.service.business.impl;

import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.service.business.third.model.LoginUserInfo;
import com.doumee.service.business.third.model.PageData;
import com.doumee.service.business.third.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.TmsFactoryParamMapper;
import com.doumee.dao.business.model.TmsFactoryParam;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.TmsFactoryParamService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

/**
 * TMS工厂配置信息表Service实现
 * @author 江蹄蹄
 * @date 2024/12/18 17:44
 */
@Service
public class TmsFactoryParamServiceImpl implements TmsFactoryParamService {

    @Autowired
    private TmsFactoryParamMapper tmsFactoryParamMapper;

    @Override
    public Integer create(TmsFactoryParam model) {
        if(tmsFactoryParamMapper.selectCount(new QueryWrapper<TmsFactoryParam>().lambda()
                .eq(TmsFactoryParam::getIsdeleted, Constants.ZERO)
                .eq(TmsFactoryParam::getCode,model.getCode())
        )>0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，工厂编码不能重复！");
        }
        model.setIsdeleted(Constants.ZERO);
        model.setCreator(model.getLoginUserInfo().getId());
        model.setCreateDate(new Date());
        model.setEditDate(model.getCreateDate());
        model.setEditor(model.getCreator());
        tmsFactoryParamMapper.insert(model);
        return model.getId();
    }

    @Override
    public void deleteById(Integer id, LoginUserInfo user) {
        tmsFactoryParamMapper.update(null,
                new UpdateWrapper<TmsFactoryParam>()
                .lambda()
                .set(TmsFactoryParam::getIsdeleted,Constants.ONE)
                .eq(TmsFactoryParam::getId,id)
                .set(TmsFactoryParam::getEditDate,new Date())
                .set(TmsFactoryParam::getEditor,user.getId())
        );
    }

    @Override
    public void delete(TmsFactoryParam tmsFactoryParam) {
        UpdateWrapper<TmsFactoryParam> deleteWrapper = new UpdateWrapper<>(tmsFactoryParam);
        tmsFactoryParamMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids, LoginUserInfo user) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for(Integer id : ids){
            deleteById(id,user);
        }
    }

    @Override
    public void updateById(TmsFactoryParam model) {
        if(tmsFactoryParamMapper.selectCount(new QueryWrapper<TmsFactoryParam>().lambda()
                .eq(TmsFactoryParam::getIsdeleted, Constants.ZERO)
                .ne(TmsFactoryParam::getId,model.getId())
                .eq(TmsFactoryParam::getCode,model.getCode())
        )>0){
            throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，工厂编码不能重复！");
        }
        model.setEditor(model.getLoginUserInfo().getId());
        model.setEditDate(model.getCreateDate());
        tmsFactoryParamMapper.updateById(model);
    }

    @Override
    public void updateByIdInBatch(List<TmsFactoryParam> tmsFactoryParams) {
        if (CollectionUtils.isEmpty(tmsFactoryParams)) {
            return;
        }
        for (TmsFactoryParam tmsFactoryParam: tmsFactoryParams) {
            this.updateById(tmsFactoryParam);
        }
    }

    @Override
    public TmsFactoryParam findById(Integer id) {
        return tmsFactoryParamMapper.selectById(id);
    }

    @Override
    public TmsFactoryParam findOne(TmsFactoryParam tmsFactoryParam) {
        QueryWrapper<TmsFactoryParam> wrapper = new QueryWrapper<>(tmsFactoryParam);
        return tmsFactoryParamMapper.selectOne(wrapper);
    }

    @Override
    public List<TmsFactoryParam> findList(TmsFactoryParam tmsFactoryParam) {
        tmsFactoryParam.setIsdeleted(Constants.ZERO);
        QueryWrapper<TmsFactoryParam> wrapper = new QueryWrapper<>(tmsFactoryParam);
        return tmsFactoryParamMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<TmsFactoryParam> findPage(PageWrap<TmsFactoryParam> pageWrap) {
        IPage<TmsFactoryParam> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<TmsFactoryParam> queryWrapper = new MPJLambdaWrapper<>();
        Utils.MP.blankToNull(pageWrap.getModel());
        pageWrap.getModel().setIsdeleted(Constants.ZERO);
        queryWrapper.selectAll(TmsFactoryParam.class)
                .selectAs(SystemUser::getRealname,TmsFactoryParam::getEditorName)
                .leftJoin(SystemUser.class,SystemUser::getId,TmsFactoryParam::getEditor);
        if (pageWrap.getModel().getId() != null) {
             queryWrapper.eq(TmsFactoryParam::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getCreator() != null) {
             queryWrapper.eq(TmsFactoryParam::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
             queryWrapper.ge(TmsFactoryParam::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
             queryWrapper.le(TmsFactoryParam::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
             queryWrapper.eq(TmsFactoryParam::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
             queryWrapper.ge(TmsFactoryParam::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
             queryWrapper.le(TmsFactoryParam::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
             queryWrapper.eq(TmsFactoryParam::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getRemark() != null) {
             queryWrapper.eq(TmsFactoryParam::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getCode() != null) {
             queryWrapper.like(TmsFactoryParam::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getName() != null) {
             queryWrapper.like(TmsFactoryParam::getName, pageWrap.getModel().getName());
        }
        if (pageWrap.getModel().getSortnum() != null) {
             queryWrapper.eq(TmsFactoryParam::getSortnum, pageWrap.getModel().getSortnum());
        }
        if (pageWrap.getModel().getNum1() != null) {
             queryWrapper.eq(TmsFactoryParam::getNum1, pageWrap.getModel().getNum1());
        }
        if (pageWrap.getModel().getNum2() != null) {
             queryWrapper.eq(TmsFactoryParam::getNum2, pageWrap.getModel().getNum2());
        }
        if (pageWrap.getModel().getParam3() != null) {
             queryWrapper.eq(TmsFactoryParam::getParam3, pageWrap.getModel().getParam3());
        }
        if (pageWrap.getModel().getParam4() != null) {
             queryWrapper.eq(TmsFactoryParam::getParam4, pageWrap.getModel().getParam4());
        }
        queryWrapper.orderByAsc( TmsFactoryParam::getSortnum);
        return PageData.from(tmsFactoryParamMapper.selectPage(page, queryWrapper));
    }

    @Override
    public long count(TmsFactoryParam tmsFactoryParam) {
        QueryWrapper<TmsFactoryParam> wrapper = new QueryWrapper<>(tmsFactoryParam);
        return tmsFactoryParamMapper.selectCount(wrapper);
    }
}