package com.utils;  // 声明工具类所在包

import java.util.Arrays;  // 导入数组工具类
import java.util.HashMap;  // 导入HashMap类
import java.util.Iterator;  // 导入迭代器接口
import java.util.Map;  // 导入Map接口

import org.apache.commons.lang3.StringUtils;  // 导入字符串工具类

import cn.hutool.core.bean.BeanUtil;  // 导入Bean工具类

import com.baomidou.mybatisplus.mapper.Wrapper;  // 导入MyBatis-Plus条件构造器

public class MPUtil {  // MyBatis-Plus工具类
	public static final char UNDERLINE = '_';  // 下划线常量

	// 带前缀的AllEQ条件转换
	public static Map allEQMapPre(Object bean,String pre) {
		Map<String, Object> map =BeanUtil.beanToMap(bean);  // 将Bean转为Map
		return camelToUnderlineMap(map,pre);  // 转换键名并返回
	}

	// AllEQ条件转换
	public static Map allEQMap(Object bean) {
		Map<String, Object> map =BeanUtil.beanToMap(bean);  // 将Bean转为Map
		return camelToUnderlineMap(map,"");  // 转换键名并返回
	}

	// 带前缀的LIKE条件构造
	public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) {
		Map<String, Object> map =BeanUtil.beanToMap(bean);  // 将Bean转为Map
		Map result = camelToUnderlineMap(map,pre);  // 转换键名
		return genLike(wrapper,result);  // 生成LIKE条件
	}

	// LIKE条件构造
	public static Wrapper allLike(Wrapper wrapper,Object bean) {
		Map result = BeanUtil.beanToMap(bean, true, true);  // 将Bean转为Map(忽略空值)
		return genLike(wrapper,result);  // 生成LIKE条件
	}

	// 生成LIKE条件
	public static Wrapper genLike(Wrapper wrapper,Map param) {
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();  // 获取迭代器
		int i=0;  // 计数器
		while (it.hasNext()) {  // 遍历Map
			if(i>0) wrapper.and();  // 多个条件用AND连接
			Map.Entry<String, Object> entry = it.next();  // 获取键值对
			String key = entry.getKey();  // 获取字段名
			String value = (String) entry.getValue();  // 获取字段值
			wrapper.like(key, value);  // 添加LIKE条件
			i++;  // 计数器递增
		}
		return wrapper;  // 返回条件构造器
	}

	// LIKE或EQ条件构造
	public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
		Map result = BeanUtil.beanToMap(bean, true, true);  // 将Bean转为Map(忽略空值)
		return genLikeOrEq(wrapper,result);  // 生成LIKE或EQ条件
	}

	// 生成LIKE或EQ条件
	public static Wrapper genLikeOrEq(Wrapper wrapper,Map param) {
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();  // 获取迭代器
		int i=0;  // 计数器
		while (it.hasNext()) {  // 遍历Map
			if(i>0) wrapper.and();  // 多个条件用AND连接
			Map.Entry<String, Object> entry = it.next();  // 获取键值对
			String key = entry.getKey();  // 获取字段名
			if(entry.getValue().toString().contains("%")) {  // 判断是否包含%通配符
				wrapper.like(key, entry.getValue().toString().replace("%", ""));  // 添加LIKE条件
			} else {
				wrapper.eq(key, entry.getValue());  // 添加EQ条件
			}
			i++;  // 计数器递增
		}
		return wrapper;  // 返回条件构造器
	}

	// 全等条件构造
	public static Wrapper allEq(Wrapper wrapper,Object bean) {
		Map result = BeanUtil.beanToMap(bean, true, true);  // 将Bean转为Map(忽略空值)
		return genEq(wrapper,result);  // 生成EQ条件
	}

	// 生成EQ条件
	public static Wrapper genEq(Wrapper wrapper,Map param) {
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();  // 获取迭代器
		int i=0;  // 计数器
		while (it.hasNext()) {  // 遍历Map
			if(i>0) wrapper.and();  // 多个条件用AND连接
			Map.Entry<String, Object> entry = it.next();  // 获取键值对
			String key = entry.getKey();  // 获取字段名
			wrapper.eq(key, entry.getValue());  // 添加EQ条件
			i++;  // 计数器递增
		}
		return wrapper;  // 返回条件构造器
	}

	// BETWEEN条件构造
	public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
		for(String key : params.keySet()) {  // 遍历参数Map
			String columnName = "";  // 列名变量
			if(key.endsWith("_start")) {  // 判断是否是起始值
				columnName = key.substring(0, key.indexOf("_start"));  // 提取列名
				if(StringUtils.isNotBlank(params.get(key).toString())) {  // 判断值非空
					wrapper.ge(columnName, params.get(key));  // 添加大于等于条件
				}
			}
			if(key.endsWith("_end")) {  // 判断是否是结束值
				columnName = key.substring(0, key.indexOf("_end"));  // 提取列名
				if(StringUtils.isNotBlank(params.get(key).toString())) {  // 判断值非空
					wrapper.le(columnName, params.get(key));  // 添加小于等于条件
				}
			}
		}
		return wrapper;  // 返回条件构造器
	}

	// 排序条件构造
	public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
		String order = "";  // 排序方式变量
		if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {  // 获取排序方式
			order = params.get("order").toString();  // 设置排序方式
		}
		if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {  // 获取排序字段
			if(order.equalsIgnoreCase("desc")) {  // 判断是否降序
				wrapper.orderDesc(Arrays.asList(params.get("sort")));  // 添加降序条件
			} else {
				wrapper.orderAsc(Arrays.asList(params.get("sort")));  // 添加升序条件
			}
		}
		return wrapper;  // 返回条件构造器
	}

	// 驼峰转下划线方法
	public static String camelToUnderline(String param) {
		if (param == null || "".equals(param.trim())) {  // 参数检查
			return "";  // 返回空字符串
		}
		int len = param.length();  // 获取字符串长度
		StringBuilder sb = new StringBuilder(len);  // 创建字符串构建器
		for (int i = 0; i < len; i++) {  // 遍历字符串
			char c = param.charAt(i);  // 获取当前字符
			if (Character.isUpperCase(c)) {  // 判断是否大写字母
				sb.append(UNDERLINE);  // 添加下划线
				sb.append(Character.toLowerCase(c));  // 添加小写字母
			} else {
				sb.append(c);  // 直接添加字符
			}
		}
		return sb.toString();  // 返回转换结果
	}

	// 测试方法
	public static void main(String[] ages) {
		System.out.println(camelToUnderline("ABCddfANM"));  // 测试驼峰转下划线
	}

	// Map键名驼峰转下划线
	public static Map camelToUnderlineMap(Map param, String pre) {
		Map<String, Object> newMap = new HashMap<String, Object>();  // 创建新Map
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();  // 获取迭代器
		while (it.hasNext()) {  // 遍历原Map
			Map.Entry<String, Object> entry = it.next();  // 获取键值对
			String key = entry.getKey();  // 获取键名
			String newKey = camelToUnderline(key);  // 转换键名格式
			if (pre.endsWith(".")) {  // 判断前缀是否以点结尾
				newMap.put(pre + newKey, entry.getValue());  // 添加带前缀的键值对
			} else if (StringUtils.isEmpty(pre)) {  // 判断前缀是否为空
				newMap.put(newKey, entry.getValue());  // 添加无前缀的键值对
			} else {
				newMap.put(pre + "." + newKey, entry.getValue());  // 添加带前缀的键值对
			}
		}
		return newMap;  // 返回新Map
	}
}