/**
 * KRA - Auto Code Service
 * Code generation related APIs
 * 
 * 自动代码生成服务，支持 Kratos DDD 架构的后端代码和 React 前端代码生成
 */
import { request } from '@umijs/max';
import type { ApiResponse } from '@/types/api';

// ==================== 数据源相关类型 ====================

/**
 * 数据源配置
 * 用于字段关联其他表的数据
 */
export interface DataSource {
  /** 数据库名称 */
  dbName: string;
  /** 关联表名 */
  table: string;
  /** 显示字段（用于下拉框显示） */
  label: string;
  /** 值字段（用于下拉框值） */
  value: string;
  /** 关联类型：0-无关联，1-一对一，2-一对多 */
  association: number;
  /** 关联表是否有 deleted_at 字段 */
  hasDeletedAt: boolean;
}

// ==================== 自定义查询方法相关类型 ====================

/**
 * 自定义方法参数
 */
export interface CustomMethodParam {
  /** 参数名称 */
  name: string;
  /** 参数类型 (string, int, uint, bool, time.Time等) */
  type: string;
  /** 对应的字段名 (用于生成查询条件) */
  fieldName: string;
}

/**
 * 自定义查询条件
 */
export interface CustomCondition {
  /** 字段名 */
  fieldName: string;
  /** 操作符: eq, neq, gt, gte, lt, lte, like, in, between, isNull, isNotNull */
  operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'in' | 'between' | 'isNull' | 'isNotNull';
  /** 参数名 (对应 CustomMethodParam.name) */
  paramName: string;
}

/**
 * 自定义查询方法
 * 用于在 GORM Gen 生成的代码中添加自定义查询方法
 */
export interface CustomMethod {
  /** 方法名称 (如: FindByName, GetActiveUsers) */
  name: string;
  /** 方法描述 */
  description: string;
  /** 返回类型: single(单个), list(列表), count(计数), exists(存在检查) */
  returnType: 'single' | 'list' | 'count' | 'exists';
  /** 方法参数 */
  params: CustomMethodParam[];
  /** 查询条件 */
  conditions: CustomCondition[];
  /** 排序字段 (如: created_at DESC) */
  orderBy?: string;
  /** 限制数量 (0表示不限制) */
  limit?: number;
}

// ==================== 字段搜索类型 ====================

/**
 * 字段搜索类型枚举
 */
export type FieldSearchType = 
  | ''        // 不搜索
  | 'LIKE'    // 模糊搜索
  | 'EQ'      // 等于
  | 'NEQ'     // 不等于
  | 'GT'      // 大于
  | 'GTE'     // 大于等于
  | 'LT'      // 小于
  | 'LTE'     // 小于等于
  | 'BETWEEN' // 范围搜索
  | 'IN';     // 包含

/**
 * 字段索引类型枚举
 */
export type FieldIndexType = 
  | ''           // 无索引
  | 'index'      // 普通索引
  | 'unique'     // 唯一索引
  | 'primaryKey'; // 主键

// ==================== 自动代码字段类型 ====================

/**
 * 自动代码字段配置
 * 对应后端 AutoCodeField 结构体
 */
export interface AutoCodeField {
  /** 字段名称（Go 结构体字段名，首字母大写） */
  fieldName: string;
  /** 字段描述（中文说明） */
  fieldDesc: string;
  /** 字段类型（Go 类型：string, int, uint, bool, float64, time.Time, datatypes.JSON 等） */
  fieldType: string;
  /** JSON 字段名（小驼峰） */
  fieldJson: string;
  /** 数据库字段类型（如：varchar(255), int(11), text, datetime 等） */
  dataTypeLong: string;
  /** 字段注释 */
  comment: string;
  /** 数据库列名（蛇形命名） */
  columnName: string;
  /** 搜索类型 */
  fieldSearchType: FieldSearchType;
  /** 是否隐藏搜索条件 */
  fieldSearchHide?: boolean;
  /** 字典类型（关联 sys_dictionaries 表） */
  dictType?: string;
  /** 是否在表单中显示 */
  form?: boolean;
  /** 是否在表格中显示 */
  table?: boolean;
  /** 是否在详情中显示 */
  desc?: boolean;
  /** 是否支持 Excel 导入导出 */
  excel?: boolean;
  /** 是否必填 */
  require: boolean;
  /** 默认值 */
  defaultValue?: string;
  /** 错误提示文本 */
  errorText?: string;
  /** 是否可清空 */
  clearable?: boolean;
  /** 是否支持排序 */
  sort: boolean;
  /** 是否为主键 */
  primaryKey: boolean;
  /** 数据源配置（用于关联其他表） */
  dataSource?: DataSource;
  /** 是否检查数据源 */
  checkDataSource?: boolean;
  /** 字段索引类型 */
  fieldIndexType?: FieldIndexType;
  /** 是否仅数字（用于输入验证） */
  onlyNumber?: string;
  /** 是否禁用 */
  disabled?: boolean;
  /** 数据类型（前端使用） */
  dataType?: string;
}

// ==================== 生成选项类型 ====================

/**
 * 代码生成选项
 * 控制代码生成的各种行为
 */
export interface GenerateOptions {
  /** 是否使用 KRA_MODEL（包含 ID, CreatedAt, UpdatedAt, DeletedAt） */
  gvaModel?: boolean;
  /** 是否自动迁移数据库 */
  autoMigrate?: boolean;
  /** 是否创建资源字段 */
  autoCreateResource?: boolean;
  /** 是否自动创建 API 记录到数据库 */
  autoCreateApiToSql?: boolean;
  /** 是否自动创建菜单到数据库 */
  autoCreateMenuToSql?: boolean;
  /** 是否自动创建按钮权限 */
  autoCreateBtnAuth?: boolean;
  /** 是否仅生成模板（不注入到现有文件） */
  onlyTemplate?: boolean;
  /** 是否为树形结构 */
  isTree?: boolean;
  /** 树形结构 JSON 字段名 */
  treeJson?: string;
  /** 是否为追加模式（追加到现有文件） */
  isAdd?: boolean;
  /** 是否生成前端代码 */
  generateWeb?: boolean;
  /** 是否生成后端代码 */
  generateServer?: boolean;
}

/**
 * 模板类型枚举
 */
export type TemplateType = 'package' | 'plugin';

// ==================== 自动代码参数类型 ====================

/**
 * 自动代码生成参数
 * 对应后端 AutoCodeRequest 结构体
 */
export interface AutoCodeParams {
  /** 包名（小写，用于目录名） */
  package?: string;
  /** 包名（首字母大写） */
  packageT?: string;
  /** 数据库表名 */
  tableName: string;
  /** 业务数据库名（多数据库场景） */
  businessDB?: string;
  /** 结构体名称（首字母大写） */
  structName: string;
  /** 包名（小写） */
  packageName: string;
  /** 功能描述（中文） */
  description: string;
  /** 缩写（用于路由前缀和变量名） */
  abbreviation: string;
  /** 驼峰包名 */
  humpPackageName?: string;
  /** Go 模块名（从 go.mod 读取） */
  module?: string;

  // ========== 生成选项 ==========
  /** 是否使用 KRA_MODEL（包含 ID, CreatedAt, UpdatedAt, DeletedAt） */
  gvaModel?: boolean;
  /** 是否自动迁移数据库 */
  autoMigrate?: boolean;
  /** 是否创建资源字段 */
  autoCreateResource?: boolean;
  /** 是否自动创建 API 记录到数据库 */
  autoCreateApiToSql?: boolean;
  /** 是否自动创建菜单到数据库 */
  autoCreateMenuToSql?: boolean;
  /** 是否自动创建按钮权限 */
  autoCreateBtnAuth?: boolean;
  /** 是否仅生成模板（不注入到现有文件） */
  onlyTemplate?: boolean;
  /** 是否为树形结构 */
  isTree?: boolean;
  /** 树形结构 JSON 字段名 */
  treeJson?: string;
  /** 是否为追加模式（追加到现有文件） */
  isAdd?: boolean;
  /** 是否生成前端代码 */
  generateWeb?: boolean;
  /** 是否生成后端代码 */
  generateServer?: boolean;
  /** 是否自动移动文件（已废弃） */
  autoMoveFile?: boolean;
  /** 模板类型：package（标准包）或 plugin（插件） */
  templateType?: TemplateType;

  // ========== 字段配置 ==========
  /** 字段列表 */
  fields: AutoCodeField[];
  /** 主键字段 */
  primaryField?: AutoCodeField;
  /** 数据源映射 */
  dataSourceMap?: Record<string, DataSource>;
  /** 字典类型列表 */
  dictTypes?: string[];
  /** 自定义查询方法 */
  customMethods?: CustomMethod[];

  // ========== 特性标记（自动检测） ==========
  /** 是否包含图片字段 */
  hasPic?: boolean;
  /** 是否包含文件字段 */
  hasFile?: boolean;
  /** 是否包含时间字段 */
  hasTimer?: boolean;
  /** 是否包含搜索时间字段 */
  hasSearchTimer?: boolean;
  /** 是否包含富文本字段 */
  hasRichText?: boolean;
  /** 是否包含数据源字段 */
  hasDataSource?: boolean;
  /** 是否包含数组字段 */
  hasArray?: boolean;
  /** 是否支持 Excel 导入导出 */
  hasExcel?: boolean;
  /** 是否需要排序 */
  needSort?: boolean;
  /** 是否需要 JSON 处理 */
  needJSON?: boolean;
  /** 是否有自定义查询方法 */
  hasCustomMethods?: boolean;
}

// ==================== 数据库元数据类型 ====================

/**
 * 数据库信息
 */
export interface DatabaseInfo {
  /** 数据库名称 */
  database: string;
}

/**
 * 数据表信息
 */
export interface TableInfo {
  /** 表名 */
  tableName: string;
  /** 表注释 */
  tableComment?: string;
}

/**
 * 数据列信息
 */
export interface ColumnInfo {
  /** 列名 */
  columnName: string;
  /** 数据类型 */
  dataType: string;
  /** 完整数据类型（包含长度） */
  dataTypeLong: string;
  /** 列注释 */
  columnComment: string;
  /** 是否为主键 */
  primaryKey: boolean;
  /** 是否可为空 */
  nullable: boolean;
  /** 默认值 */
  defaultValue?: string;
}

// ==================== 历史记录类型 ====================

/**
 * 自动代码生成历史记录
 */
export interface AutoCodeHistory {
  /** 记录 ID */
  ID: number;
  /** 创建时间 */
  CreatedAt: string;
  /** 更新时间 */
  UpdatedAt: string;
  /** 表名 */
  tableName: string;
  /** 包名 */
  package: string;
  /** 结构体名 */
  structName: string;
  /** 缩写 */
  abbreviation: string;
  /** 业务数据库 */
  businessDB: string;
  /** 描述 */
  description: string;
  /** 生成的模板文件路径 */
  templates: Record<string, string>;
  /** 注入信息 */
  injections: Record<string, string>;
  /** API ID 列表 */
  apiIDs: number[];
  /** 菜单 ID */
  menuID: number;
  /** 导出模板 ID */
  exportTemplateID: number;
}

// ==================== 包管理类型 ====================

/**
 * 自动代码包信息
 */
export interface AutoCodePackage {
  /** 包 ID */
  ID: number;
  /** 创建时间 */
  CreatedAt: string;
  /** 更新时间 */
  UpdatedAt: string;
  /** 包名 */
  packageName: string;
  /** 模板类型：package（标准包）或 plugin（插件） */
  template: TemplateType;
  /** 包描述 */
  desc?: string;
  /** 包标签 */
  label?: string;
}

// ==================== 函数添加类型 ====================

/**
 * 添加函数参数
 */
export interface AddFuncParams {
  /** 包名 */
  package: string;
  /** 函数名 */
  funcName: string;
  /** 路由路径 */
  router: string;
  /** 函数描述 */
  funcDesc: string;
  /** 业务数据库 */
  businessDB?: string;
  /** 结构体名 */
  structName: string;
  /** 包名（小写） */
  packageName: string;
  /** 描述 */
  description: string;
  /** 缩写 */
  abbreviation: string;
  /** 驼峰包名 */
  humpPackageName: string;
  /** HTTP 方法 */
  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
  /** 是否为插件 */
  isPlugin?: boolean;
  /** 是否需要认证 */
  isAuth?: boolean;
  /** 是否为预览模式 */
  isPreview?: boolean;
  /** 是否为 AI 生成 */
  isAi?: boolean;
  /** API 函数代码（AI 生成时使用） */
  apiFunc?: string;
  /** Server 函数代码（AI 生成时使用） */
  serverFunc?: string;
  /** JS 函数代码（AI 生成时使用） */
  jsFunc?: string;
}

// ==================== LLM 相关类型 ====================

/**
 * LLM 自动生成参数
 */
export interface LLMAutoParams {
  /** 提示词 */
  prompt: string;
  /** 模式：ai, butler, eye, painter */
  mode?: 'ai' | 'butler' | 'eye' | 'painter';
}

/**
 * Eye 模式参数（图片识别）
 */
export interface EyeParams {
  /** Base64 编码的图片 */
  picture: string;
  /** 命令/指令 */
  command: string;
}

// ==================== MCP 相关类型 ====================

/**
 * MCP 工具参数
 */
export interface MCPParams {
  /** 工具名称 */
  tool: string;
  /** 工具参数 */
  params: Record<string, any>;
}

/**
 * MCP 工具信息
 */
export interface MCPTool {
  /** 工具名称 */
  name: string;
  /** 工具描述 */
  description: string;
  /** 输入参数 Schema */
  inputSchema: Record<string, any>;
}

// ==================== 回滚参数类型 ====================

/**
 * 回滚参数
 */
export interface RollbackParams {
  /** 历史记录 ID */
  id: number;
  /** 是否删除 API 记录 */
  deleteApi?: boolean;
  /** 是否删除菜单 */
  deleteMenu?: boolean;
  /** 是否删除数据表 */
  deleteTable?: boolean;
}

// ==================== 预览结果类型 ====================

/**
 * 代码预览结果
 */
export interface PreviewResult {
  /** 自动代码预览内容，key 为文件路径，value 为代码内容 */
  autoCode: Record<string, string>;
}

// ==================== API 函数 ====================

/**
 * 预览生成代码
 * @param data 自动代码生成参数
 * @returns 预览结果，包含各文件的代码内容
 */
export const preview = (data: AutoCodeParams) => {
  return request<ApiResponse<PreviewResult>>('/autoCode/preview', { method: 'POST', data });
};

/**
 * 创建临时文件（生成代码）
 * @param data 自动代码生成参数
 * @returns 生成结果
 */
export const createTemp = (data: AutoCodeParams) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/createTemp', { method: 'POST', data });
};

/**
 * 获取所有数据库
 * @param params 查询参数
 * @returns 数据库列表
 */
export const getDB = (params?: { businessDB?: string; dbName?: string }) => {
  return request<ApiResponse<{ dbs: string[]; dbList: DatabaseInfo[] }>>('/autoCode/getDB', { method: 'GET', params });
};

/**
 * 获取数据库中的所有表
 * @param params 查询参数，包含数据库名
 * @returns 表列表
 */
export const getTables = (params: { dbName: string }) => {
  return request<ApiResponse<{ tables: TableInfo[] }>>('/autoCode/getTables', { method: 'GET', params });
};

/**
 * 获取表列表（别名）
 * @param params 查询参数
 * @returns 表列表
 */
export const getTable = (params: { businessDB?: string; dbName?: string }) => {
  return request<ApiResponse<{ tables: TableInfo[] }>>('/autoCode/getTable', { method: 'GET', params });
};

/**
 * 获取表的列信息
 * @param params 查询参数，包含数据库名和表名
 * @returns 列信息列表
 */
export const getColumn = (params: { businessDB?: string; dbName?: string; tableName: string }) => {
  return request<ApiResponse<{ columns: ColumnInfo[] }>>('/autoCode/getColumn', { method: 'GET', params });
};

/**
 * 获取系统历史记录
 * @param data 分页参数
 * @returns 历史记录列表
 */
export const getSysHistory = (data: { page: number; pageSize: number }) => {
  return request<ApiResponse<{ list: AutoCodeHistory[]; total: number }>>('/autoCode/getSysHistory', { method: 'POST', data });
};

/**
 * 回滚生成的代码
 * @param data 回滚参数
 * @returns 回滚结果
 */
export const rollback = (data: RollbackParams) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/rollback', { method: 'POST', data });
};

/**
 * 获取元信息
 * @param data 包含历史记录 ID
 * @returns 元信息
 */
export const getMeta = (data: { id: number }) => {
  return request<ApiResponse<{ meta: string; [key: string]: any }>>('/autoCode/getMeta', { method: 'POST', data });
};

/**
 * 删除系统历史记录
 * @param data 包含历史记录 ID
 * @returns 删除结果
 */
export const delSysHistory = (data: { id: number }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/delSysHistory', { method: 'POST', data });
};

/**
 * 创建包
 * @param data 包名
 * @returns 创建结果
 */
export const createPackage = (data: { packageName: string }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/createPackage', { method: 'POST', data });
};

/**
 * 获取包列表
 * @returns 包列表
 */
export const getPackage = () => {
  return request<ApiResponse<{ pkgs: AutoCodePackage[] }>>('/autoCode/getPackage', { method: 'POST' });
};

/**
 * 删除包
 * @param data 包名
 * @returns 删除结果
 */
export const deletePackage = (data: { packageName: string }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/delPackage', { method: 'POST', data });
};

/**
 * 获取模板列表
 * @returns 模板列表
 */
export const getTemplates = () => {
  return request<ApiResponse<{ templates: string[] }>>('/autoCode/getTemplates', { method: 'GET' });
};

/**
 * 安装插件
 * @param data 插件信息
 * @returns 安装结果
 */
export const installPlug = (data: { plugName: string; [key: string]: any }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/installPlug', { method: 'POST', data });
};

/**
 * 发布插件
 * @param params 插件名称
 * @returns 发布结果
 */
export const pubPlug = (params: { plugName: string }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/pubPlug', { method: 'POST', params });
};

/**
 * LLM 自动代码生成
 * @param data 包含提示词
 * @returns 生成的代码
 */
export const llmAuto = (data: LLMAutoParams) => {
  return request<ApiResponse<string>>('/autoCode/llmAuto', { 
    method: 'POST', 
    data: { ...data, mode: 'ai' }, 
    timeout: 1000 * 60 * 10 
  });
};

/**
 * Butler 模式（管家模式）
 * @param data 请求参数
 * @returns 处理结果
 */
export const butler = (data: LLMAutoParams & Record<string, any>) => {
  return request<ApiResponse<any>>('/autoCode/llmAuto', { 
    method: 'POST', 
    data: { ...data, mode: 'butler' }, 
    timeout: 1000 * 60 * 10 
  });
};

/**
 * Eye 模式（图片识别）
 * @param data 包含图片和命令
 * @returns 识别结果
 */
export const eye = (data: EyeParams) => {
  return request<ApiResponse<string>>('/autoCode/llmAuto', { 
    method: 'POST', 
    data: { ...data, mode: 'eye' }, 
    timeout: 1000 * 60 * 10 
  });
};

/**
 * 创建 Web 页面（Painter 模式）
 * @param data 请求参数
 * @returns 生成的页面代码
 */
export const createWeb = (data: Record<string, any>) => {
  return request<ApiResponse<any>>('/autoCode/llmAuto', { 
    method: 'POST', 
    data: { ...data, mode: 'painter' }, 
    timeout: 1000 * 60 * 10 
  });
};

/**
 * 添加函数
 * @param data 函数信息
 * @returns 添加结果
 */
export const addFunc = (data: AddFuncParams) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/addFunc', { method: 'POST', data });
};

/**
 * 初始化菜单
 * @param data 菜单信息
 * @returns 初始化结果
 */
export const initMenu = (data: { menuId?: number; [key: string]: any }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/initMenu', { method: 'POST', data });
};

/**
 * 初始化 API
 * @param data API 信息
 * @returns 初始化结果
 */
export const initAPI = (data: { apiId?: number; [key: string]: any }) => {
  return request<ApiResponse<{ msg: string }>>('/autoCode/initAPI', { method: 'POST', data });
};

/**
 * MCP 工具调用
 * @param data MCP 参数
 * @returns 调用结果
 */
export const mcp = (data: MCPParams) => {
  return request<ApiResponse<any>>('/autoCode/mcp', { method: 'POST', data });
};

/**
 * 获取 MCP 工具列表
 * @param data 查询参数
 * @returns 工具列表
 */
export const mcpList = (data: Record<string, any>) => {
  return request<ApiResponse<{ tools: MCPTool[] }>>('/autoCode/mcpList', { method: 'POST', data });
};

/**
 * 测试 MCP 工具
 * @param data 测试参数
 * @returns 测试结果
 */
export const mcpTest = (data: MCPParams) => {
  return request<ApiResponse<any>>('/autoCode/mcpTest', { method: 'POST', data });
};

// ==================== 生成选项辅助类型 ====================

/**
 * 创建包请求参数
 */
export interface CreatePackageParams {
  /** 包名 */
  packageName: string;
  /** 包描述 */
  desc?: string;
  /** 包标签 */
  label?: string;
  /** 模板类型 */
  template?: TemplateType;
}

/**
 * 生成结果
 */
export interface GenerateResult {
  /** 生成的文件路径列表 */
  files?: string[];
  /** 注入的文件路径列表 */
  injections?: string[];
  /** 历史记录 ID */
  historyId?: number;
  /** 消息 */
  msg?: string;
}

/**
 * 默认生成选项
 * 用于初始化表单时的默认值
 */
export const DEFAULT_GENERATE_OPTIONS: GenerateOptions = {
  gvaModel: true,
  autoMigrate: true,
  autoCreateResource: false,
  autoCreateApiToSql: true,
  autoCreateMenuToSql: true,
  autoCreateBtnAuth: false,
  onlyTemplate: false,
  isTree: false,
  treeJson: '',
  isAdd: false,
  generateWeb: true,
  generateServer: true,
};

/**
 * 默认字段模板
 * 用于创建新字段时的默认值
 */
export const DEFAULT_FIELD_TEMPLATE: Omit<AutoCodeField, 'fieldName' | 'fieldDesc' | 'fieldType' | 'fieldJson' | 'columnName'> = {
  dataTypeLong: '',
  comment: '',
  fieldSearchType: '',
  fieldSearchHide: false,
  dictType: '',
  form: true,
  table: true,
  desc: true,
  excel: false,
  require: false,
  defaultValue: '',
  errorText: '',
  clearable: true,
  sort: false,
  primaryKey: false,
  checkDataSource: false,
  fieldIndexType: '',
};

/**
 * 字段类型到 TypeScript 类型的映射
 */
export const FIELD_TYPE_TO_TS_MAP: Record<string, string> = {
  'string': 'string',
  'int': 'number',
  'uint': 'number',
  'int64': 'number',
  'uint64': 'number',
  'float64': 'number',
  'bool': 'boolean',
  'time.Time': 'string',
  'datatypes.JSON': 'Record<string, any>',
  'json': 'Record<string, any>',
  'array': 'any[]',
  'picture': 'string',
  'pictures': 'string[]',
  'video': 'string',
  'file': 'string[]',
  'richtext': 'string',
  'enum': 'string',
};

/**
 * 字段类型选项
 */
export const FIELD_TYPE_OPTIONS = [
  { label: '字符串', value: 'string' },
  { label: '富文本', value: 'richtext' },
  { label: '整型', value: 'int' },
  { label: '布尔值', value: 'bool' },
  { label: '浮点型', value: 'float64' },
  { label: '时间', value: 'time.Time' },
  { label: '枚举', value: 'enum' },
  { label: '单图片（字符串）', value: 'picture' },
  { label: '多图片（json字符串）', value: 'pictures' },
  { label: '视频（字符串）', value: 'video' },
  { label: '文件（json字符串）', value: 'file' },
  { label: 'JSON', value: 'json' },
  { label: '数组', value: 'array' },
] as const;

/**
 * 搜索条件选项
 */
export const SEARCH_TYPE_OPTIONS = [
  { label: '=', value: 'EQ' },
  { label: '<>', value: 'NEQ' },
  { label: '>', value: 'GT' },
  { label: '>=', value: 'GTE' },
  { label: '<', value: 'LT' },
  { label: '<=', value: 'LTE' },
  { label: 'LIKE', value: 'LIKE' },
  { label: 'BETWEEN', value: 'BETWEEN' },
  { label: 'IN', value: 'IN' },
] as const;

/**
 * 索引类型选项
 */
export const INDEX_TYPE_OPTIONS = [
  { label: '普通索引', value: 'index' },
  { label: '唯一索引', value: 'unique' },
  { label: '主键', value: 'primaryKey' },
] as const;

/**
 * 模板类型选项
 */
export const TEMPLATE_TYPE_OPTIONS = [
  { label: '标准包', value: 'package' as TemplateType },
  { label: '插件', value: 'plugin' as TemplateType },
] as const;

// ==================== 辅助函数 ====================

/**
 * 创建默认的 AutoCodeParams
 * @param overrides 覆盖的属性
 * @returns AutoCodeParams
 */
export const createDefaultAutoCodeParams = (overrides?: Partial<AutoCodeParams>): AutoCodeParams => ({
  tableName: '',
  structName: '',
  packageName: '',
  description: '',
  abbreviation: '',
  fields: [],
  ...DEFAULT_GENERATE_OPTIONS,
  templateType: 'package',
  ...overrides,
});

/**
 * 创建默认的字段
 * @param fieldName 字段名
 * @param fieldDesc 字段描述
 * @param fieldType 字段类型
 * @param overrides 覆盖的属性
 * @returns AutoCodeField
 */
export const createDefaultField = (
  fieldName: string,
  fieldDesc: string,
  fieldType: string,
  overrides?: Partial<AutoCodeField>
): AutoCodeField => ({
  fieldName,
  fieldDesc,
  fieldType,
  fieldJson: fieldName.charAt(0).toLowerCase() + fieldName.slice(1),
  columnName: fieldName.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, ''),
  ...DEFAULT_FIELD_TEMPLATE,
  ...overrides,
});

/**
 * 验证 AutoCodeParams 是否有效
 * @param params 参数
 * @returns 验证结果
 */
export const validateAutoCodeParams = (params: AutoCodeParams): { valid: boolean; errors: string[] } => {
  const errors: string[] = [];
  
  if (!params.structName) {
    errors.push('请输入结构体名称');
  }
  if (!params.abbreviation) {
    errors.push('请输入结构体简称');
  }
  if (!params.description) {
    errors.push('请输入结构体描述');
  }
  if (!params.packageName) {
    errors.push('请输入文件名称');
  }
  if (!params.package) {
    errors.push('请选择模板');
  }
  if (!params.generateWeb && !params.generateServer) {
    errors.push('请至少选择一个生成项');
  }
  if (!params.onlyTemplate && params.fields.length === 0) {
    errors.push('请填写至少一个字段');
  }
  if (!params.gvaModel && params.fields.length > 0 && !params.fields.some(f => f.primaryKey)) {
    errors.push('您至少需要创建一个主键才能保证自动化代码的可行性');
  }
  if (params.isTree && !params.treeJson) {
    errors.push('请填写树型结构的前端展示json属性');
  }
  if (params.structName === params.abbreviation) {
    errors.push('structName和struct简称不能相同');
  }
  if (params.package === params.abbreviation) {
    errors.push('package和结构体简称不可同名');
  }
  
  return {
    valid: errors.length === 0,
    errors,
  };
};
