package com.lxzn.base.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.MultilevelDictionaryMapper;
import com.lxzn.base.service.IMultilevelDictionaryService;
import com.lxzn.base.service.support.DictionaryTreeWrapper;
import com.lxzn.framework.domain.base.MultilevelDictionary;
import com.lxzn.framework.domain.base.ext.MultilevelDictionaryExt;
import com.lxzn.framework.domain.base.request.MultilevelDictionaryRequest;
import com.lxzn.framework.domain.base.response.MultilevelDictionaryCode;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.CommonJsonTree;
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 MultilevelDictionaryServiceImpl extends ServiceImpl<MultilevelDictionaryMapper, MultilevelDictionary> implements IMultilevelDictionaryService {

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDictionary(MultilevelDictionary dictionary) {
        if(dictionary == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(dictionary.getTypeCode()))
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_TYPE_CODE_NONE);
        if(!ValidateUtil.validateString(dictionary.getDicName()))
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_NAME_NONE);
        if(!ValidateUtil.validateInteger(dictionary.getDicValue()))
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_VALUE_NONE);
        String dicCode = dictionary.getTypeCode() + "_" + dictionary.getDicValue();
        dictionary.setDicCode(dicCode);
        MultilevelDictionary en = findByDicCode(dictionary.getDicCode());
        if(en != null) {
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_CODE_EXIST);
        }
        if (ValidateUtil.validateString(dictionary.getParentId())) {
            en = super.getById(dictionary.getParentId());
            if(en == null) {
                ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_PARENT_NOT_EXIST);
            }
            dictionary.setRankLevel(en.getRankLevel() + 1);
        } else {
            dictionary.setParentId(null);
            dictionary.setRankLevel(1);
        }
        return super.save(dictionary);
    }

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

    @Override
    public QueryPageResponseResult<MultilevelDictionary> findByPageList(int page, int size, MultilevelDictionaryRequest requestParams) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<MultilevelDictionary> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<MultilevelDictionary> lambdaQuery = super.lambdaQuery();
        if(requestParams != null) {
            if(ValidateUtil.validateString(requestParams.getTypeCode())) {
                lambdaQuery.eq(MultilevelDictionary::getTypeCode, requestParams.getTypeCode());
            }
            if(ValidateUtil.validateString(requestParams.getDicCode())) {
                lambdaQuery.like(MultilevelDictionary::getDicCode, requestParams.getDicCode());
            }
            if(ValidateUtil.validateString(requestParams.getDicName())) {
                lambdaQuery.like(MultilevelDictionary::getDicName, requestParams.getDicName());
            }
            if(ValidateUtil.validateString(requestParams.getId())) {
                lambdaQuery.eq(MultilevelDictionary::getParentId,requestParams.getId());
            }
            if(ValidateUtil.validateString(requestParams.getAscStr())) {
                String[] ascArr = requestParams.getAscStr().split(",");
                ((Page<MultilevelDictionary>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(requestParams.getDescStr())) {
                String[] descStr = requestParams.getDescStr().split(",");
                ((Page<MultilevelDictionary>) pageData).setDesc(descStr);
            }
        }
        IPage<MultilevelDictionary> userIPage = lambdaQuery.page(pageData);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, userIPage);
    }

    @Override
    public List<CommonJsonTree> loadTree() {
        List<MultilevelDictionaryExt> multilevelExt = this.getBaseMapper().findExtAll();
        return DictionaryTreeWrapper.loadTree(multilevelExt);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editDictionary(String id, MultilevelDictionary dictionary) {
        if(!ValidateUtil.validateString(id) || dictionary == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        MultilevelDictionary en = super.getById(id);
        if (en == null) {
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_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(MultilevelDictionaryCode.MULTI_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);
        }
        MultilevelDictionary en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_NOT_EXIST);
        List<MultilevelDictionary> list =  findByParentId(id);
        if (list != null && list.size()> 0) {
            ExceptionCast.cast(MultilevelDictionaryCode.MULTI_DIC_SON);
        }
        return super.removeById(id);
    }

    @Override
    public List<MultilevelDictionary> findByParentId(String parentId) {
        if(!ValidateUtil.validateString(parentId))
            return null;
        List<MultilevelDictionary> list = super.lambdaQuery().eq(MultilevelDictionary::getParentId, parentId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    public List<MultilevelDictionaryExt>  findListByTypeCode(String typeCode) {
        if(!ValidateUtil.validateString(typeCode))
            return null;
        List<MultilevelDictionaryExt> multilevelExt = this.getBaseMapper().findListByTypeCode(typeCode);
        if(multilevelExt == null || multilevelExt.isEmpty())
            return null;
        return multilevelExt;
    }

    @Override
    public String queryDictTextByKey(String typeCode, String dicValue){
        LambdaQueryWrapper<MultilevelDictionary> lambdaQueryWrapper=new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(StrUtil.isNotEmpty(typeCode), MultilevelDictionary::getTypeCode, typeCode);
        lambdaQueryWrapper.eq(StrUtil.isNotEmpty(dicValue), MultilevelDictionary::getDicValue, dicValue);
        lambdaQueryWrapper.eq(MultilevelDictionary::getDeleteFlag, 0);
        return this.getBaseMapper().selectOne(lambdaQueryWrapper).getDicName();
    }
}