package com.vci.ubcs.starter.util;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import org.springblade.core.mp.support.SqlKeyword;
import org.springblade.core.tool.utils.BeanUtil;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * in 参数截取，返回wrapper/或者where条件字符串
 *
 * @author ludc
 * @date 2023/5/5
 */
public class MybatisParameterUtil {

	/**
	 * Oracle IN 查询的最大参数限制
 	 */
	private static final int MAX_IN_CLAUSE_SIZE = 1000;

	/**
	 * 将给定的 ID 列表转换为适合 Oracle 的查询条件
	 *
	 * @param ids ID 列表
	 * @return 适合 Oracle 的查询条件
	 */
	public static String convertToOrConditions(String filed,List<String> ids) {
		if (ids == null || ids.isEmpty()) {
			return "";
		}

		StringBuilder queryBuilder = new StringBuilder();
		int size = ids.size();

		// 分批处理，避免超过 Oracle IN 查询的最大限制
		for (int i = 0; i < size; i += MAX_IN_CLAUSE_SIZE) {
			int end = Math.min(i + MAX_IN_CLAUSE_SIZE, size);
			List<String> subList = ids.subList(i, end);
			if (queryBuilder.length() > 0) {
				queryBuilder.append(" OR ");
			}
			queryBuilder.append("(")
				.append(getInClause(filed,subList)).append(")");
		}

		return queryBuilder.toString();
	}

	/*
	 * 获取 IN 查询条件字符串
	 * @param ids ID 列表
	 * @return IN 查询条件字符串
	 */
	private static String getInClause(String filed,List<String> ids) {
		StringBuilder inClauseBuilder = new StringBuilder();
		inClauseBuilder.append(filed + " IN (");

		for (int i = 0; i < ids.size(); i++) {
			inClauseBuilder.append("'").append(ids.get(i)).append("'");
			if (i < ids.size() - 1) {
				inClauseBuilder.append(", ");
			}
		}
		inClauseBuilder.append(")");

		return inClauseBuilder.toString();
	}

	/**
	 * 获取 IN 查询条件字符串（不包含in）
	 *
	 * @param ids ID 列表
	 * @return IN 查询条件字符串
	 */
	public static String getInClause(List<String> ids) {
		StringBuilder inClauseBuilder = new StringBuilder();
		for (int i = 0; i < ids.size(); i++) {
			inClauseBuilder.append("'").append(ids.get(i)).append("'");
			if (i < ids.size() - 1) {
				inClauseBuilder.append(", ");
			}
		}
		return inClauseBuilder.toString();
	}

	/**
	 * in作为查询条件时，防止大于1000出现报错，对条件进行截取，连表查询的wrapper
	 * @param wrapper MPJLambdaWrapper,不进行连表查询时使用
	 * @param column 作为in的条件列
	 * @param coll 查询参数
	 * @param <T> LambdaQueryWrapper的泛型
	 * @param <F> 查询参数类型
	 * @return
	 * @throws VciBaseException
	 */
	public static <T, F> MPJLambdaWrapper<T> cutInParameter(MPJLambdaWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
		List<List<F>> newList = splitList(coll, 900);
		if (ObjectUtils.isEmpty(newList)) {
			throw new VciBaseException("参数错误");
		} else if (newList.size() == 1) {
			wrapper.in(column, newList.get(0));
			return wrapper;
		}
		wrapper.and(i -> {
			i.in(column, newList.get(0));
			newList.remove(0);
			for (List<F> objects : newList) {
				i.or().in(column, objects);
			}
		});
		return wrapper;
	}

	/**
	 * in作为查询条件时，防止大于1000出现报错，对条件进行截取，不具备连表查询的wrapper
	 * @param wrapper LambdaQueryWrapper,不进行连表查询时使用
	 * @param column 作为in的条件列
	 * @param coll 查询参数
	 * @param <T> LambdaQueryWrapper的泛型
	 * @param <F> 查询参数类型
	 * @return
	 * @throws VciBaseException
	 */
	public static <T, F> LambdaQueryWrapper<T> cutInParameter(LambdaQueryWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
		List<List<F>> newList = splitList(coll, 900);
		if (ObjectUtils.isEmpty(newList)) {
			throw new VciBaseException("参数错误");
		} else if (newList.size() == 1) {
			wrapper.in(column, newList.get(0));
			return wrapper;
		}
		wrapper.and(i -> {
			i.in(column, newList.get(0));
			newList.remove(0);
			for (List<F> objects : newList) {
				i.or().in(column, objects);
			}
		});
		return wrapper;
	}

	/**
	 * notin作为查询条件时，防止大于1000出现报错，对条件进行截取，连表查询的wrapper
	 * @param wrapper MPJLambdaWrapper,不进行连表查询时使用
	 * @param column 作为in的条件列
	 * @param coll 查询参数
	 * @param <T> LambdaQueryWrapper的泛型
	 * @param <F> 查询参数类型
	 * @return
	 * @throws VciBaseException
	 */
	public static <T, F> MPJLambdaWrapper<T> cutNotInParameter(MPJLambdaWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
		List<List<F>> newList = splitList(coll, 900);
		if (ObjectUtils.isEmpty(newList)) {
			throw new VciBaseException("参数错误");
		} else if (newList.size() == 1) {
			wrapper.notIn(column, newList.get(0));
			return wrapper;
		}
		wrapper.and(i -> {
			i.in(column, newList.get(0));
			newList.remove(0);
			for (List<F> objects : newList) {
				i.or().notIn(column, objects);
			}
		});
		return wrapper;
	}

	/**
	 * notin作为查询条件时，防止大于1000出现报错，对条件进行截取，不具备连表查询的wrapper
	 * @param wrapper LambdaQueryWrapper,不进行连表查询时使用
	 * @param column 作为in的条件列
	 * @param coll 查询参数
	 * @param <T> LambdaQueryWrapper的泛型
	 * @param <F> 查询参数类型
	 * @return
	 * @throws VciBaseException
	 */
	public static <T, F> LambdaQueryWrapper<T> cutNotInParameter(LambdaQueryWrapper<T> wrapper, SFunction<T, ?> column, List<F> coll) throws VciBaseException {
		List<List<F>> newList = splitList(coll, 900);
		if (ObjectUtils.isEmpty(newList)) {
			throw new VciBaseException("参数错误");
		} else if (newList.size() == 1) {
			wrapper.notIn(column, newList.get(0));
			return wrapper;
		}
		wrapper.and(i -> {
			i.in(column, newList.get(0));
			newList.remove(0);
			for (List<F> objects : newList) {
				i.or().notIn(column, objects);
			}
		});
		return wrapper;
	}

	public static <F> List<List<F>> splitList(List<F> list, int groupSize) {
		int length = list.size();
		// 计算可以分成多少组
		int num = (length + groupSize - 1) / groupSize;
		List<List<F>> newList = new ArrayList<>(num);
		for (int i = 0; i < num; i++) {
			// 开始位置
			int fromIndex = i * groupSize;
			// 结束位置
			int toIndex = Math.min((i + 1) * groupSize, length);
			newList.add(list.subList(fromIndex, toIndex));
		}
		return newList;
	}

}