/**
#                                                    __----~~~~~~~~~~~------___
#                                   .  .   ~~//====......          __--~ ~~
#                   -.            \_|//     |||\\  ~~~~~~::::... /~
#                ___-==_       _-~o~  \/    |||  \\            _/~~-
#        __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~
#    _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /
#  .~       .~       |   \\ -_    /  /-   /   ||      \   /
# /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /
# |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\
#          '         ~-|      /|    |-~\~~       __--~~
#                      |-~~-_/ |    |   ~\_   _-~            /\
#                           /  \     \__   \/~                \__
#                       _--~ _/ | .-~~____--~-/                  ~~==.
#                      ((->/~   '.|||' -_|    ~~-/ ,              . _||
#                                 -_     ~\      ~~---l__i__i__i--~~_/
#                                 _-~-__   ~)  \--______________--~~
#                               //.-~~~-~_--~- |-------~~~~~~~~
#                                      //.-~~~--\
#                  神兽保佑
#                  永无BUG！
*/
package com.nanjing.water.repository.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nanjing.water.common.PagerResult;
import com.nanjing.water.common.util.ListUtil;
import com.nanjing.water.common.util.NumericUtil;
import com.nanjing.water.common.util.StringUtil;
import com.nanjing.water.entity.dto.OrderByDTO;
import com.nanjing.water.entity.dto.SearchBasicDTO;
import com.nanjing.water.entity.enums.EOrderBy;
import com.nanjing.water.entity.search.SearchSysDictData;
import com.nanjing.water.repository.BasicMapperImpl;
import com.nanjing.water.repository.mapper.SysDictDataMapper;
import com.nanjing.water.repository.po.SysDictDataPO;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 字典数据表
 * @author lin.liu
 * @description 字典数据表
 */
@Repository
public class SysDictDataMapperImpl extends BasicMapperImpl<SysDictDataPO, SysDictDataMapper> {
	SysDictDataMapperImpl(SysDictDataMapper mapper) {
		super(mapper);
	}

	@Override
	public PagerResult<SysDictDataPO> search(SearchBasicDTO request) {
		// 还原查询条件真实类型
		SearchSysDictData search = (SearchSysDictData)request;
		// 查询条件
		LambdaQueryWrapper<SysDictDataPO> queryWrapper = this.query();
		// 状态
		queryWrapper.eq(NumericUtil.tryParseInt(search.getStatus()).compareTo(0) > 0, SysDictDataPO::getStatus, search.getStatus());
		// 状态列表
		queryWrapper.in(ListUtil.isNotNullOrEmpty(search.getListStatus()), SysDictDataPO::getStatus, search.getListStatus());

		// 数据创建时间-起始
		queryWrapper.ge(NumericUtil.tryParseLong(search.getCreateTimeStart()).compareTo(0L) > 0, SysDictDataPO::getCreateTime, search.getCreateTimeStart());
		// 数据创建时间-截止
		queryWrapper.le(NumericUtil.tryParseLong(search.getCreateTimeEnd()).compareTo(0L) > 0, SysDictDataPO::getCreateTime, search.getCreateTimeEnd());
		// 关键字
		if (StringUtil.isNotNullOrEmpty(search.getKeywords())) {
			queryWrapper.like(SysDictDataPO::getDictLabel, search.getKeywords());
		}

		// 排序处理
		if (ListUtil.isNotNullOrEmpty(search.getOrderBy())) {
			for (OrderByDTO item : search.getOrderBy()) {
				EOrderBy orderBy = EOrderBy.getByValue(item.getOrderBy());
				// 顺序排序
				if (item.getIsAsc()) {
					switch (orderBy) {
						// 主键
						case ID:
							queryWrapper.orderByAsc(SysDictDataPO::getId);
							break;
						// 数据创建时间
						case CREATE_TIME:
							queryWrapper.orderByAsc(SysDictDataPO::getCreateTime);
							break;
						// 最后更新时间
						case UPDATE_TIME:
							queryWrapper.orderByAsc(SysDictDataPO::getUpdateTime);
							break;
					}
				} else {
					// 倒叙排序
					switch (orderBy) {
						// 主键
						case ID:
							queryWrapper.orderByDesc(SysDictDataPO::getId);
							break;
						// 数据创建时间
						case CREATE_TIME:
							queryWrapper.orderByDesc(SysDictDataPO::getCreateTime);
							break;
						// 最后更新时间
						case UPDATE_TIME:
							queryWrapper.orderByDesc(SysDictDataPO::getUpdateTime);
							break;
					}
				}
			}
		} else {
			queryWrapper.orderByDesc(SysDictDataPO::getId);
		}
		Page<SysDictDataPO> pageResult = super.selectPage(new Page<>(search.getPage(), search.getLimit()), queryWrapper);
		return new PagerResult<>(pageResult.getSize(), pageResult.getCurrent(), pageResult.getTotal(), pageResult.getRecords());
	}

	public Boolean add(SysDictDataPO item) {
		int rowCount = super.insert(item);
		return rowCount == 1;
	}
	/**
	 * 根据type获取数据列表
	 * @param type 类型
	 */
	public List<SysDictDataPO> getListByType(String type) {
		LambdaQueryWrapper<SysDictDataPO> queryWrapper = this.query();
         queryWrapper.eq(SysDictDataPO::getDictType, type);
         return DB.selectList(queryWrapper);
	}
	public Long count4Type(String type) {
		LambdaQueryWrapper<SysDictDataPO> queryWrapper = this.query();
		queryWrapper.eq(SysDictDataPO::getDictType, type);
		return DB.getCount(queryWrapper);
	}
	public List<String> findExists4Type(List<String> listType) {
		LambdaQueryWrapper<SysDictDataPO> queryWrapper = this.query();
		queryWrapper.select(SysDictDataPO.class, c -> c.getColumn().equals("dict_type"));
		queryWrapper.in(SysDictDataPO::getDictType, listType);
		List<Map<String, Object>> result = DB.selectMaps(queryWrapper);
		return result.stream().map(c -> c.get("dict_type").toString()).distinct().collect(Collectors.toList());
	}

	public Boolean addNotIncrement(SysDictDataPO item) {
		int rowCount = super.insert(item);
		return rowCount == 1;
	}

	public SysDictDataPO getById(Long id) {
		return super.get(id);
	}

	public List<SysDictDataPO> getListById(List<Long> listId) {
		return super.getList(listId);
	}

	public List<SysDictDataPO> listByType(List<String> listType) {
		LambdaQueryWrapper<SysDictDataPO> queryWrapper = this.query();
		queryWrapper.in(SysDictDataPO::getDictType, listType);
		return DB.selectList(queryWrapper);
	}

	public Map<String, Map<String, String>> map4Type(List<String> listType) {
		Map<String, Map<String, String>> result = new HashMap<>();

		List<SysDictDataPO> listDictData = this.listByType(listType);
		Map<String, List<SysDictDataPO>> map4Type = listDictData.stream().collect(Collectors.groupingBy(SysDictDataPO::getDictType));
		for (Map.Entry<String, List<SysDictDataPO>> entry : map4Type.entrySet()) {
			Map<String, String> mapData = entry.getValue().stream().collect(
					Collectors.toMap(SysDictDataPO::getDictValue, SysDictDataPO::getDictLabel)
			);
			result.put(entry.getKey(), mapData);
		}
		return result;
	}

	public Map<String, SysDictDataPO> map4Type(String type) {
		List<SysDictDataPO> listDictData = this.getListByType(type);
		if (ListUtil.isNullOrEmpty(listDictData)) {
			return new HashMap<>();
		}
		return listDictData.stream().collect(Collectors.toMap(SysDictDataPO::getDictValue, c -> c));
	}
}