package com.seeyon.apps.src_flowIntegration.util;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * SQL语句参数处理
 */
public class SQLParamUtil {

    /**
     * 基础版：直接拼接，null元素会转为"null"字符串，空字符串保留
     * （JDK 8+ 推荐，极简写法）
     * @param array 目标字符串数组
     * @return 逗号分隔的字符串，空数组返回空字符串
     */
    public static String joinWithComma(String[] array) {
        // 空值校验：避免传入null导致空指针
        if (array == null || array.length == 0) {
            return "";
        }
        return String.join(",", array);
    }

    /**
     * 增强版：过滤null和空字符串（含纯空格），仅保留有效元素
     * @param array 目标字符串数组
     * @return 逗号分隔的有效元素字符串，无有效元素返回空字符串
     */
    public static String joinWithCommaFilterEmpty(String[] array) {
        if (array == null || array.length == 0) {
            return "";
        }
        // 流式处理：过滤null、空字符串、纯空格字符串
        return Arrays.stream(array)
                .filter(str -> str != null && !str.trim().isEmpty())
                .collect(Collectors.joining(","));
    }

    /**
     * 兼容版：支持JDK 7及以下，手动循环拼接，可选择是否过滤空值
     * @param array 目标字符串数组
     * @param filterEmpty 是否过滤null和空字符串（true=过滤，false=不过滤）
     * @return 逗号分隔的字符串
     */
    public static String joinWithCommaCompat(String[] array, boolean filterEmpty) {
        if (array == null || array.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < array.length; i++) {
            String element = array[i];
            // 过滤逻辑：根据参数决定是否跳过无效元素
            if (filterEmpty && (element == null || element.trim().isEmpty())) {
                continue;
            }
            // 处理null元素：转为空字符串（避免拼接出"null"）
            String addStr = element == null ? "" : element;
            // 添加元素
            sb.append(addStr);
            // 处理逗号：仅当不是最后一个有效元素时添加
            if (i != array.length - 1) {
                // 预判下一个元素是否需要处理（避免末尾多余逗号）
                boolean hasNextValid = false;
                for (int j = i + 1; j < array.length; j++) {
                    String next = array[j];
                    if (!filterEmpty || (next != null && !next.trim().isEmpty())) {
                        hasNextValid = true;
                        break;
                    }
                }
                if (hasNextValid) {
                    sb.append(",");
                }
            }
        }
        return sb.toString();
    }

    /**
     * 将Map<String, String>转换为 and key = 'value' and key = 'value' 格式的字符串
     * @param paramMap 目标Map（键值均为字符串）
     * @return 格式化字符串，空Map/Null返回空字符串
     */
    public static String mapToAndCondition(Map<String, String> paramMap) {
        // 1. 空值校验：Map为null或空，直接返回空字符串
        if (paramMap == null || paramMap.isEmpty()) {
            return "";
        }

        // 2. 遍历Map，拼接每个 key = 'value' 片段（自动转义值中的单引号）
        String conditionSegments = paramMap.entrySet().stream()
                // 过滤null键/值（避免拼接出 and null = 'null' 这种无效条件）
                .filter(entry -> entry.getKey() != null && entry.getValue() != null)
                // 拼接单个条件片段：key = 'value'（转义值中的单引号，如 'a'b' → 'a''b'）
                .map(entry -> {
                    String key = entry.getKey().trim();
                    String value = escapeSingleQuote(entry.getValue().trim());
                    return key + " = '" + value + "'";
                })
                // 用 " and " 连接所有片段
                .collect(Collectors.joining(" and "));

        // 3. 如果有有效片段，前面加 "and "；无有效片段返回空字符串
        return conditionSegments.isEmpty() ? "" : "and " + conditionSegments;
    }

    /**
     * 转义字符串中的单引号（避免SQL注入/语法错误）
     * 例如：O'Neil → O''Neil
     * @param str 原始字符串
     * @return 转义后的字符串
     */
    private static String escapeSingleQuote(String str) {
        if (str == null) {
            return "";
        }
        // 将单个单引号替换为两个单引号（SQL标准转义方式）
        return str.replace("'", "''");
    }


    // ------------------- 测试用例 -------------------
    public static void main(String[] args) {

    }
}
