import { resourceManager } from "@kit.LocalizationKit";
import { IdCardNumUtils } from "./IdCardNumUtils";

export class StringUtils {
  /**
   * 获取字符串, 如果为空则返回默认值, 如果非空则返回该值并拼接endStr到末尾
   * @param value         要获取的字符串
   * @param defValue      默认值
   * @param endStr        要拼接的字符串
   * @returns value+endStr || defValue
   */
  static get(value: string | Object | undefined | null, defValue: string, endStr?: string): string {
    if (StringUtils.isNullOrEmpty(value)) {
      return defValue;
    }
    if (endStr) {
      return String(value) + endStr;
    }
    return String(value);
  }

  /**
   * 判断值是否为空
   * @param value
   * @returns
   */
  static isNullOrEmpty(value: string | Object | undefined | null): boolean {
    return value == null || value == undefined || value.toString().trim().length < 1;
  }

  /**
   * 获取数字， 如果为空或者不是数字类型的字符则返回默认值, 如果是number或者数字字符串者返回该值的number值
   * @param value         要获取的字符串
   * @param defValue      默认值
   * @returns value|| defValue
   */
  static getNumber(value: string | number | null | undefined, defValue: number = 0): number {
    // 处理空值和未定义情况
    if (value === null || value === undefined) {
      return defValue;
    }
    // 处理数字类型直接返回
    if (typeof value === 'number') {
      return value;
    }
    // 处理字符串类型
    if (typeof value === 'string') {
      // 去除首尾空格
      const trimmedValue = value.trim();

      // 正则验证数字格式（包含整数、小数、科学计数法）
      const isNumeric = /^[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?$/.test(trimmedValue);

      // 有效数字则进行转换
      if (isNumeric) {
        const numberValue = Number(trimmedValue);
        return Number.isNaN(numberValue) ? defValue : numberValue;
      }
    }
    // 非数字类型返回默认值
    return defValue;
  }

  /**
   *
   * @param str           待查找源字符串
   * @param char          待匹配的目标
   * @returns true 表示包含     false 表示不包含
   */
  static containsChar(str: string, char: string): boolean {
    //当 str 内含有 char  则返回 char所在位置索引 即 返回值大与 -1
    return str.indexOf(char) > -1;
  }

  /**
   * 去除JSON字符串 转义字符
   * @param value   需要转译的字符
   * @return 转译后的JSON格式数据
   */
  public static toJsonParaphrase(value: string): string {
    if (value == null || value.length < 1) {
      return "";
    }
    let isJx = true;
    while (isJx) {
      //去除 \\
      if (StringUtils.containsChar(value, "\\\\")) {
        value = value.replace("\\\\", "").replaceAll("\\\\", "");
      }
      isJx = StringUtils.containsChar(value, "\\\\");
    }
    isJx = true;
    while (isJx) {
      //转 \" 替换为 "
      if (StringUtils.containsChar(value, "\\\"")) {
        value = value.replace("\\\"", "\"").replaceAll("\\\"", "\"");
      }
      isJx = StringUtils.containsChar(value, "\\\"");
    }
    isJx = true;
    while (isJx) {
      //转 "{ 替换为 {
      if (StringUtils.containsChar(value, "\"{")) {
        value = value.replace("\"{", "{").replaceAll("\"{", "{");
      }
      isJx = StringUtils.containsChar(value, "\"{");
    }
    isJx = true;
    while (isJx) {
      //转 }" 替换为 }
      if (StringUtils.containsChar(value, "}\"")) {
        value = value.replace("}\"", "}").replaceAll("}\"", "}");
      }
      isJx = StringUtils.containsChar(value, "}\"");
    }
    isJx = true;
    while (isJx) {
      //转 "[ 替换为 [
      if (StringUtils.containsChar(value, "\"[")) {
        value = value.replace("\"[", "[").replaceAll("\"[", "[");
      }
      isJx = StringUtils.containsChar(value, "\"[");
    }
    isJx = true;
    while (isJx) {
      //转 ]" 替换为 ]
      if (StringUtils.containsChar(value, "]\"")) {
        value = value.replace("]\"", "]").replaceAll("]\"", "]");
      }
      isJx = StringUtils.containsChar(value, "]\"");
    }
    return value;
  }

  /**
   * 生成指定范围内的随机数
   * @param min 最小数（包含）
   * @param max 最大数（不包含）
   * @return 随机数
   */
  public static randomNumber(min: number, max: number): number {
    return Math.floor(Math.random() * (max - min) + min);
  }

  /**
   * 获取资源字符串
   * @param context
   * @param resource
   * @returns
   */
  public static getResourceString(context: Context, resource: Resource): string {
    let resourceString: string = '';
    try {
      resourceString = context.resourceManager.getStringSync(resource.id);
    } catch (error) {
      console.error('getResourceString err:' + JSON.stringify(error));
    }
    return resourceString;
  }

  /**
   * 检查16进制颜色
   * @param colorStr
   * @returns
   */
  public static isValidHexColor(colorStr: string): boolean {
    // 正则表达式匹配标准格式
    const hexRegex = /^#?([A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/
    return hexRegex.test(colorStr)
  }

  /**
   * 严格检查16进制颜色
   * @param colorStr
   * @returns
   */
  public static strictCheckHexColor(colorStr: string): boolean {
    if (!StringUtils.isValidHexColor(colorStr)) return false

    try {
      // 移除#符号并补齐透明度通道
      const cleanStr = colorStr.replace('#', '')
      const fullHex = cleanStr.length === 6 ? `FF${cleanStr}` : cleanStr

      // 尝试转换为数值验证有效性
      const colorValue = parseInt(fullHex, 16)
      return !isNaN(colorValue) && colorValue >= 0
    } catch {
      return false
    }
  }
}