/**
 * 计划书字段条件规则引擎
 *
 * @description 定义条件操作符和评估逻辑，支持复杂的字段显示/隐藏条件
 * @module config/plan-conditions
 * @author Claude Code
 * @created 2026-02-15
 * @version 1.0.0
 */

/**
 * 条件操作符定义
 *
 * @description 所有可用的条件比较操作符
 * @type {Object<string, Function>}
 */
export const CONDITION_OPERATORS = {
  // ========== 比较操作 ==========

  /**
   * 等于（严格相等）
   * @param {*} actual - 实际值
   * @param {*} expected - 期望值
   * @returns {boolean}
   */
  eq: (actual, expected) => actual === expected,

  /**
   * 不等于
   * @param {*} actual - 实际值
   * @param {*} expected - 期望值
   * @returns {boolean}
   */
  ne: (actual, expected) => actual !== expected,

  /**
   * 大于
   * @param {number} actual - 实际值
   * @param {number} expected - 期望值
   * @returns {boolean}
   */
  gt: (actual, expected) => {
    const num = Number(actual)
    const exp = Number(expected)
    return !Number.isNaN(num) && !Number.isNaN(exp) && num > exp
  },

  /**
   * 大于等于
   * @param {number} actual - 实际值
   * @param {number} expected - 期望值
   * @returns {boolean}
   */
  gte: (actual, expected) => {
    const num = Number(actual)
    const exp = Number(expected)
    return !Number.isNaN(num) && !Number.isNaN(exp) && num >= exp
  },

  /**
   * 小于
   * @param {number} actual - 实际值
   * @param {number} expected - 期望值
   * @returns {boolean}
   */
  lt: (actual, expected) => {
    const num = Number(actual)
    const exp = Number(expected)
    return !Number.isNaN(num) && !Number.isNaN(exp) && num < exp
  },

  /**
   * 小于等于
   * @param {number} actual - 实际值
   * @param {number} expected - 期望值
   * @returns {boolean}
   */
  lte: (actual, expected) => {
    const num = Number(actual)
    const exp = Number(expected)
    return !Number.isNaN(num) && !Number.isNaN(exp) && num <= exp
  },

  // ========== 集合操作 ==========

  /**
   * 包含于（值在数组中）
   * @param {*} actual - 实际值
   * @param {Array} expected - 期望数组
   * @returns {boolean}
   */
  in: (actual, expected) => {
    if (!Array.isArray(expected)) return false
    return expected.includes(actual)
  },

  /**
   * 不包含于（值不在数组中）
   * @param {*} actual - 实际值
   * @param {Array} expected - 期望数组
   * @returns {boolean}
   */
  nin: (actual, expected) => {
    if (!Array.isArray(expected)) return true
    return !expected.includes(actual)
  },

  // ========== 字符串操作 ==========

  /**
   * 字符串包含
   * @param {string} actual - 实际值
   * @param {string} expected - 期望子串
   * @returns {boolean}
   */
  contains: (actual, expected) => {
    return String(actual ?? '').includes(String(expected ?? ''))
  },

  /**
   * 字符串前缀匹配
   * @param {string} actual - 实际值
   * @param {string} expected - 期望前缀
   * @returns {boolean}
   */
  startsWith: (actual, expected) => {
    return String(actual ?? '').startsWith(String(expected ?? ''))
  },

  /**
   * 字符串后缀匹配
   * @param {string} actual - 实际值
   * @param {string} expected - 期望后缀
   * @returns {boolean}
   */
  endsWith: (actual, expected) => {
    return String(actual ?? '').endsWith(String(expected ?? ''))
  },

  /**
   * 正则表达式匹配
   * @param {string} actual - 实际值
   * @param {string|RegExp} expected - 正则表达式
   * @returns {boolean}
   */
  matches: (actual, expected) => {
    try {
      const regex = expected instanceof RegExp ? expected : new RegExp(expected)
      return regex.test(String(actual ?? ''))
    } catch {
      return false
    }
  },

  // ========== 布尔/空值操作 ==========

  /**
   * 真值检查
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  truthy: (actual) => !!actual,

  /**
   * 假值检查
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  falsy: (actual) => !actual,

  /**
   * 空值检查（null, undefined, 空字符串）
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  empty: (actual) => actual === '' || actual === null || actual === undefined,

  /**
   * 非空检查
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  notEmpty: (actual) => actual !== '' && actual !== null && actual !== undefined,

  /**
   * 空数组检查
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  emptyArray: (actual) => !Array.isArray(actual) || actual.length === 0,

  /**
   * 非空数组检查
   * @param {*} actual - 实际值
   * @returns {boolean}
   */
  notEmptyArray: (actual) => Array.isArray(actual) && actual.length > 0
}

/**
 * 操作符别名映射（向后兼容）
 *
 * @description 旧格式操作符到新格式的映射
 * @type {Object<string, string>}
 */
export const OPERATOR_ALIASES = {
  equals: 'eq',
  '==': 'eq',
  '===': 'eq',
  '!=': 'ne',
  '!==': 'ne',
  '>': 'gt',
  '>=': 'gte',
  '<': 'lt',
  '<=': 'lte'
}

/**
 * 解析操作符（支持别名）
 *
 * @param {string} op - 操作符名称或别名
 * @returns {string|null} 标准操作符名称
 */
export function normalizeOperator(op) {
  if (CONDITION_OPERATORS[op]) return op
  if (OPERATOR_ALIASES[op]) return OPERATOR_ALIASES[op]
  return null
}

/**
 * 评估单个条件
 *
 * @description 评估一个简单的条件表达式
 * @param {Object} condition - 条件对象
 * @param {string} condition.field - 字段名
 * @param {string} condition.op - 操作符
 * @param {*} condition.value - 期望值
 * @param {Object} formData - 表单数据
 * @returns {boolean} 条件是否满足
 *
 * @example
 * evaluateSingleCondition(
 *   { field: 'smoker', op: 'eq', value: '是' },
 *   { smoker: '是', age: 30 }
 * ) // true
 */
export function evaluateSingleCondition(condition, formData) {
  const { field, op, value } = condition

  if (!field || !op) {
    console.warn('[plan-conditions] 条件缺少 field 或 op:', condition)
    return false
  }

  const normalizedOp = normalizeOperator(op)
  if (!normalizedOp) {
    console.warn(`[plan-conditions] 未知操作符: ${op}`)
    return false
  }

  const operator = CONDITION_OPERATORS[normalizedOp]
  const actualValue = formData[field]

  try {
    return operator(actualValue, value)
  } catch (err) {
    console.error(`[plan-conditions] 条件评估失败:`, err)
    return false
  }
}

/**
 * 评估 AND 逻辑
 *
 * @param {Array} conditions - 条件数组
 * @param {Object} formData - 表单数据
 * @returns {boolean} 所有条件是否都满足
 */
export function evaluateAnd(conditions, formData) {
  if (!Array.isArray(conditions) || conditions.length === 0) return true
  return conditions.every(c => evaluateCondition(c, formData))
}

/**
 * 评估 OR 逻辑
 *
 * @param {Array} conditions - 条件数组
 * @param {Object} formData - 表单数据
 * @returns {boolean} 是否有任一条件满足
 */
export function evaluateOr(conditions, formData) {
  if (!Array.isArray(conditions) || conditions.length === 0) return false
  return conditions.some(c => evaluateCondition(c, formData))
}

/**
 * 评估 NOT 逻辑
 *
 * @param {Object} condition - 条件对象
 * @param {Object} formData - 表单数据
 * @returns {boolean} 条件是否不满足
 */
export function evaluateNot(condition, formData) {
  if (!condition) return false
  return !evaluateCondition(condition, formData)
}

/**
 * 评估条件（主入口）
 *
 * @description 评估任意条件表达式，支持简单条件和逻辑组合
 * @param {Object|Array} condition - 条件表达式
 * @param {Object} formData - 表单数据
 * @returns {boolean} 条件是否满足
 *
 * @example
 * // 简单条件
 * evaluateCondition({ field: 'smoker', op: 'eq', value: '是' }, formData)
 *
 * @example
 * // AND 条件
 * evaluateCondition({
 *   and: [
 *     { field: 'smoker', op: 'eq', value: '是' },
 *     { field: 'age', op: 'gte', value: 30 }
 *   ]
 * }, formData)
 *
 * @example
 * // OR 条件
 * evaluateCondition({
 *   or: [
 *     { field: 'smoker', op: 'eq', value: '是' },
 *     { field: 'age', op: 'gt', value: 50 }
 *   ]
 * }, formData)
 *
 * @example
 * // 嵌套条件
 * evaluateCondition({
 *   and: [
 *     { field: 'type', op: 'in', value: ['A', 'B'] },
 *     {
 *       or: [
 *         { field: 'coverage', op: 'gte', value: 100000 },
 *         { field: 'period', op: 'eq', value: '20年' }
 *       ]
 *     }
 *   ]
 * }, formData)
 */
export function evaluateCondition(condition, formData) {
  // 空条件默认为 true
  if (!condition) return true

  // 数组条件：默认为 AND 逻辑
  if (Array.isArray(condition)) {
    return evaluateAnd(condition, formData)
  }

  // 对象条件
  if (typeof condition === 'object') {
    // AND 逻辑
    if (condition.and) {
      return evaluateAnd(condition.and, formData)
    }

    // OR 逻辑
    if (condition.or) {
      return evaluateOr(condition.or, formData)
    }

    // NOT 逻辑
    if (condition.not) {
      return evaluateNot(condition.not, formData)
    }

    // 简单条件（包含 field 和 op）
    if (condition.field && condition.op) {
      return evaluateSingleCondition(condition, formData)
    }

    // 旧格式兼容：{ field: 'xxx', equals: 'yyy' }
    if (condition.field && condition.equals !== undefined) {
      return evaluateSingleCondition(
        { field: condition.field, op: 'eq', value: condition.equals },
        formData
      )
    }

    // 旧格式兼容：{ field: 'xxx', not_equals: 'yyy' }
    if (condition.field && condition.not_equals !== undefined) {
      return evaluateSingleCondition(
        { field: condition.field, op: 'ne', value: condition.not_equals },
        formData
      )
    }

    // 扁平条件对象：{ smoker: '是', age: 30 } → 所有条件 AND
    const keys = Object.keys(condition)
    if (keys.length > 0 && !keys.some(k => ['and', 'or', 'not', 'field', 'op'].includes(k))) {
      return keys.every(field => {
        const expectedValue = condition[field]
        const actualValue = formData[field]
        return actualValue === expectedValue
      })
    }
  }

  console.warn('[plan-conditions] 无法识别的条件格式:', condition)
  return false
}

/**
 * 获取条件依赖的字段列表
 *
 * @description 从条件表达式中提取所有依赖的字段名
 * @param {Object|Array} condition - 条件表达式
 * @returns {Set<string>} 依赖的字段名集合
 *
 * @example
 * getConditionDependencies({ and: [{ field: 'a', op: 'eq', value: 1 }, { field: 'b', op: 'eq', value: 2 }] })
 * // Set { 'a', 'b' }
 */
export function getConditionDependencies(condition) {
  const deps = new Set()

  if (!condition) return deps

  // 数组条件
  if (Array.isArray(condition)) {
    condition.forEach(c => {
      const subDeps = getConditionDependencies(c)
      subDeps.forEach(d => deps.add(d))
    })
    return deps
  }

  if (typeof condition === 'object') {
    // 简单条件
    if (condition.field) {
      deps.add(condition.field)
    }

    // 扁平条件对象
    const keys = Object.keys(condition)
    if (keys.length > 0 && !keys.some(k => ['and', 'or', 'not', 'field', 'op', 'equals'].includes(k))) {
      keys.forEach(k => deps.add(k))
    }

    // 递归处理逻辑组合
    if (condition.and) {
      condition.and.forEach(c => {
        const subDeps = getConditionDependencies(c)
        subDeps.forEach(d => deps.add(d))
      })
    }
    if (condition.or) {
      condition.or.forEach(c => {
        const subDeps = getConditionDependencies(c)
        subDeps.forEach(d => deps.add(d))
      })
    }
    if (condition.not) {
      const subDeps = getConditionDependencies(condition.not)
      subDeps.forEach(d => deps.add(d))
    }
  }

  return deps
}

/**
 * 将旧格式转换为新格式
 *
 * @description 将旧的 show_when 格式转换为新的条件格式
 * @param {Object|Array|string} oldFormat - 旧格式条件
 * @returns {Object|null} 新格式条件
 *
 * @example
 * // 旧格式
 * { field: 'withdrawal_mode', equals: '指定提取金额' }
 * // 转换为
 * { field: 'withdrawal_mode', op: 'eq', value: '指定提取金额' }
 *
 * @example
 * // 旧格式数组
 * [{ field: 'a', equals: 'x' }, { field: 'b', equals: 'y' }]
 * // 转换为
 * { and: [{ field: 'a', op: 'eq', value: 'x' }, { field: 'b', op: 'eq', value: 'y' }] }
 */
export function convertToNewFormat(oldFormat) {
  if (!oldFormat) return null

  // 已经是新格式
  if (oldFormat.and || oldFormat.or || oldFormat.not || oldFormat.op) {
    return oldFormat
  }

  // 旧格式单个条件
  if (oldFormat.field && oldFormat.equals !== undefined) {
    return {
      field: oldFormat.field,
      op: 'eq',
      value: oldFormat.equals
    }
  }

  // 旧格式数组
  if (Array.isArray(oldFormat) && oldFormat.length > 0) {
    const conditions = oldFormat.map(c => {
      if (c.field && c.equals !== undefined) {
        return { field: c.field, op: 'eq', value: c.equals }
      }
      return c
    })

    // 单个条件不需要包装 and
    if (conditions.length === 1) {
      return conditions[0]
    }

    return { and: conditions }
  }

  // 扁平对象格式 { smoker: '是' }
  const keys = Object.keys(oldFormat)
  if (keys.length > 0 && !keys.some(k => ['and', 'or', 'not', 'field', 'op', 'equals'].includes(k))) {
    if (keys.length === 1) {
      return { field: keys[0], op: 'eq', value: oldFormat[keys[0]] }
    }
    return {
      and: keys.map(field => ({ field, op: 'eq', value: oldFormat[field] }))
    }
  }

  return oldFormat
}