package com.lxzn.base.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxzn.base.dao.SingleDictionaryMapper;
import com.lxzn.base.service.ISingleDictionaryService;
import com.lxzn.framework.domain.base.SingleDictionary;
import com.lxzn.framework.domain.base.request.SingleDictionaryRequest;
import com.lxzn.framework.domain.base.response.DictionaryCode;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.QueryPageResponseResult;
import com.lxzn.framework.utils.ValidateUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class SingleDictionaryServiceImpl extends ServiceImpl<SingleDictionaryMapper, SingleDictionary> implements ISingleDictionaryService {

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDictionary(SingleDictionary dictionary) {
        if(dictionary == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(dictionary.getTypeCode()))
            ExceptionCast.cast(DictionaryCode.DIC_TYPE_CODE_NONE);
        if(!ValidateUtil.validateString(dictionary.getDicName()))
            ExceptionCast.cast(DictionaryCode.DIC_NAME_NONE);
        if(!ValidateUtil.validateInteger(dictionary.getDicValue()))
            ExceptionCast.cast(DictionaryCode.DIC_VALUE_NONE);

        String dicCode = dictionary.getTypeCode() + "_" + dictionary.getDicValue();
        dictionary.setDicCode(dicCode);
        SingleDictionary en = findByDicCode(dictionary.getDicCode());
        if(en != null) {
            ExceptionCast.cast(DictionaryCode.DIC_CODE_EXiST);
        }
        return super.save(dictionary);
    }

    @Override
    public SingleDictionary findByDicCode(String dicCode) {
        if(!ValidateUtil.validateString(dicCode))
            return null;
        List<SingleDictionary> list = super.lambdaQuery().eq(SingleDictionary::getDicCode, dicCode).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public QueryPageResponseResult<SingleDictionary> findPageList(int page, int size, SingleDictionaryRequest requestParams) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<SingleDictionary> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<SingleDictionary> lambdaQuery = super.lambdaQuery();
        if(requestParams != null) {
            if(ValidateUtil.validateString(requestParams.getTypeCode())) {
                lambdaQuery.eq(SingleDictionary::getTypeCode, requestParams.getTypeCode());
            }
            if(ValidateUtil.validateString(requestParams.getDicCode())) {
                lambdaQuery.like(SingleDictionary::getDicCode, requestParams.getDicCode());
            }
            if(ValidateUtil.validateString(requestParams.getDicName())) {
                lambdaQuery.like(SingleDictionary::getDicName, requestParams.getDicName());
            }

            if(ValidateUtil.validateString(requestParams.getAscStr())) {
                String[] ascArr = requestParams.getAscStr().split(",");
                ((Page<SingleDictionary>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(requestParams.getDescStr())) {
                String[] descStr = requestParams.getDescStr().split(",");
                ((Page<SingleDictionary>) pageData).setDesc(descStr);
            }
        }
        IPage<SingleDictionary> userIPage = lambdaQuery.page(pageData);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, userIPage);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editDictionary(String id, SingleDictionary dictionary) {
        if(!ValidateUtil.validateString(id) || dictionary == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        SingleDictionary en = super.getById(id);
        if (en == null) {
            ExceptionCast.cast(DictionaryCode.DIC_NOT_EXIST);
        }
        dictionary.setDicId(id);
        dictionary.setTypeCode(null);
        String dicCode = en.getTypeCode() + "_" + dictionary.getDicValue();
        dictionary.setDicCode(dicCode);
        en = findByDicCode(dictionary.getDicCode());
        if(en != null && !en.getDicId().equals(dictionary.getDicId())) {
            ExceptionCast.cast(DictionaryCode.DIC_CODE_EXiST);
        }
        return super.updateById(dictionary);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDictionaryById(String id) {
        if(!ValidateUtil.validateString(id)) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        SingleDictionary en = super.getById(id);
        if (en == null) {
            ExceptionCast.cast(DictionaryCode.DIC_NOT_EXIST);
        }
        return super.removeById(id);
    }

    @Override
    public List<SingleDictionary> findListFromTypeCode(String typeCode) {
        if(!ValidateUtil.validateString(typeCode))
            return null;
        List<SingleDictionary> list = super.lambdaQuery().eq(SingleDictionary::getTypeCode, typeCode).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }
}