import { z } from "zod"

import { achievementRaritySchema } from "./achievement"
import { paginatedSchema, sampleUserSchema } from "./common"
import { judgeStatusSchema } from "./judge-status"
import { problemLanguageSchema } from "./language"

/**
 * 题目难度。生产库 956 道题只有这三个值（旧 Django 的 Problem.difficulty choices
 * 也是这三个），前端的 DIFFICULTY 映射表按它建 —— 写成 z.string() 的话
 * 多出来的值会静默渲染成 undefined。
 */
export const problemDifficultySchema = z.enum(["Low", "Mid", "High"])

/**
 * 题目详情/列表里的难度。**可为 null** —— 比赛进行中、看的人又不是管理员时，
 * 难度和提交数一样属于「先别告诉参赛者」的信息（旧 Django 的
 * `ProblemSafeSerializer` 直接把 difficulty 放进 exclude，字段整个不下发）。
 *
 * 端上必须当「没有」处理，不要拿它去查 DIFFICULTY 映射表 —— 这正是
 * problemDifficultySchema 写成严格枚举要防的那件事。
 */
export const maskedProblemDifficultySchema = problemDifficultySchema.nullable()

/**
 * SQL 题配置与展示数据。两者都是 `problem.sql_config` / `problem.sql_display`
 * 的 **JSONB 原文**，所以键名保持 snake_case —— 生产库 9 道 SQL 题存的就是这个形状
 * （移植自旧后端 `judge/sql_runner.py:build_display`，逐条比对过，键集完全一致）。
 *
 * 写成精确 schema 而不是 `z.record(z.unknown())`：前端原来得自己手抄一份
 * SQLDisplay 接口才能渲染表格，抄错了没人拦得住。
 */
export const sqlConfigSchema = z.object({
  mode: z.enum(["query", "modify"]),
  order_sensitive: z.boolean(),
})

/** 表格里的单元格。SQLite 只会给出这三种；BLOB 在落库前已转成十六进制字符串 */
const sqlCellSchema = z.union([z.string(), z.number(), z.null()])

const sqlDisplayColumnSchema = z.object({
  name: z.string(),
  /** 表达式/聚合列（COUNT(*)、别名）在数据表里无同名列，类型为空串，前端据此隐藏 */
  type: z.string(),
})

const sqlResultSetSchema = z.object({
  columns: z.array(sqlDisplayColumnSchema),
  rows: z.array(z.array(sqlCellSchema)),
  total_rows: z.number().int().nonnegative(),
  truncated: z.boolean(),
})

export const sqlDisplayTableSchema = sqlResultSetSchema.extend({
  name: z.string(),
  /** 被标准答案 DROP 的表：条目用初始数据补齐、rows 清空，前端提示「表已删除」 */
  dropped: z.boolean().optional(),
})

export const sqlDisplaySchema = z.object({
  tables: z.array(sqlDisplayTableSchema),
  // query 题给结果集，modify 题给改动后的表 —— 两种形态，前端按有没有
  // changed_tables 分支
  expected: z.union([
    sqlResultSetSchema,
    z.object({ changed_tables: z.array(sqlDisplayTableSchema) }),
  ]),
})

/**
 * AST 代码要求。同一个形状原来在**三个地方**各写了一份，三份都不一样：
 * apps/api/src/judge/ast.ts 的 AstRule（判题机真读的那份，九个字段）、
 * apps/web/src/utils/types.ts 的 AstRules（少了 label / exact / outer / inner）、
 * AstRulesEditor.vue 里的本地 AstRule（少了 outer / inner）。
 * 编辑器写得出 label / exact，题目类型却描述不了它们。现在以这里为准。
 *
 * 除 engine 外全部可选：判题机每条规则只读自己那几个字段
 * （见 ast.ts 的 evaluateRule），缺了就走默认文案。
 */
export const astRuleEngineSchema = z.enum([
  "must_exist_node",
  "must_not_exist_node",
  "count_node",
  "must_call_function",
  "must_not_call_function",
  "count_function_call",
  "must_call_method",
  "must_not_call_method",
  "must_use_operator",
  // 判题机实现了，但后台编辑器还没有对应的选项，目前只能手工造数据用上
  "must_have_nesting",
])

export const astRuleSchema = z.object({
  engine: astRuleEngineSchema,
  /** 检查目标：节点类型 / 函数名 / 方法名 / 运算符，按 engine 而定 */
  target: z.string().optional(),
  /** must_have_nesting 专用：外层、内层节点 */
  outer: z.string().optional(),
  inner: z.string().optional(),
  /** 展示用的中文名，缺省回落到 target */
  label: z.string().optional(),
  /** 自定义提示。生产库里存的是空串而不是缺键，判题机按 `||` 回落到默认文案 */
  message: z.string().optional(),
  /** count_* 引擎的次数约束 */
  exact: z.number().int().optional(),
  min: z.number().int().optional(),
  max: z.number().int().optional(),
})

/** 按语言分组：`{ Python: [...], C: [...] }`，键是 languages 里的语言名 */
export const astRulesSchema = z.record(z.string(), z.array(astRuleSchema))

/**
 * 一个 target 一条，`label` 给人看（后台下拉、题目页的「要求」），`node` 给判题机
 * 拿去比 tree-sitter 的节点类型。
 *
 * **这两半原来是分在两个包里的两张表** —— 这边 target → 中文名，
 * `apps/api/src/judge/ast.ts` 的 mappings 是 target → tree-sitter 节点类型，靠一句
 * 「两边必须同增同减」的注释维持。只加一边是静默错判：老师给 C 题选到只有 Python
 * 有的 `list_comprehension`，判题机 `mapping[target] ?? target` 拿裸名去比节点类型，
 * C 的语法树里永远不存在它，于是「必须使用列表推导式」永远失败、「不能使用
 * f-string」永远通过，两头都不报错，只有学生受着。并成一张之后，加 target 而漏配
 * 节点类型在结构上就不可能了。
 *
 * （更早之前 AstRulesEditor.vue 和 ProblemContent.vue 还各手抄过一份中文名，
 * 且 C 和 Python 的节点混在一张 15 条的表里铺成后台下拉。）
 */
export interface AstNodeTarget {
  /** 后台下拉和题目页展示的中文名 */
  label: string
  /** tree-sitter 里对应的节点类型，判题机按它 collectNodes */
  node: string
}

const C_NODE_TARGETS = {
  for_loop: { label: "for 循环", node: "for_statement" },
  while_loop: { label: "while 循环", node: "while_statement" },
  do_while: { label: "do-while 循环", node: "do_statement" },
  if_statement: { label: "if 条件", node: "if_statement" },
  else_clause: { label: "else 子句", node: "else_clause" },
  switch_statement: { label: "switch 语句", node: "switch_statement" },
  case_statement: { label: "case 分支", node: "case_statement" },
  break: { label: "break 语句", node: "break_statement" },
  continue: { label: "continue 语句", node: "continue_statement" },
  return: { label: "return 语句", node: "return_statement" },
  function_definition: { label: "函数定义", node: "function_definition" },
  assignment: { label: "赋值语句", node: "assignment_expression" },
  struct: { label: "结构体", node: "struct_specifier" },
  include: { label: "#include 指令", node: "preproc_include" },
} satisfies Record<string, AstNodeTarget>

export const AST_NODE_TARGETS_BY_LANGUAGE: Record<string, Record<string, AstNodeTarget>> = {
  C: C_NODE_TARGETS,
  /**
   * tree-sitter-cpp 继承 tree-sitter-c 的语法，C 那 14 条在 C++ 树里逐个实测通用，
   * 所以共用的条目一律**引用** C_NODE_TARGETS 而不是抄一遍 —— 原来 C 的 14 行在
   * 契约和判题机两个文件里各抄了两遍（C 一份、C++ 一份），同一份数据四份拷贝。
   * 这里逐条列出来是为了保住下拉框的显示顺序（C++ 独有的几条是插在中间的）。
   */
  "C++": {
    for_loop: C_NODE_TARGETS.for_loop,
    range_for_loop: { label: "范围 for 循环", node: "for_range_loop" },
    while_loop: C_NODE_TARGETS.while_loop,
    do_while: C_NODE_TARGETS.do_while,
    if_statement: C_NODE_TARGETS.if_statement,
    else_clause: C_NODE_TARGETS.else_clause,
    switch_statement: C_NODE_TARGETS.switch_statement,
    case_statement: C_NODE_TARGETS.case_statement,
    break: C_NODE_TARGETS.break,
    continue: C_NODE_TARGETS.continue,
    return: C_NODE_TARGETS.return,
    function_definition: C_NODE_TARGETS.function_definition,
    class_definition: { label: "类定义", node: "class_specifier" },
    struct: C_NODE_TARGETS.struct,
    assignment: C_NODE_TARGETS.assignment,
    include: C_NODE_TARGETS.include,
    try_except: { label: "try-catch", node: "try_statement" },
    throw: { label: "throw 语句", node: "throw_statement" },
    namespace: { label: "namespace 定义", node: "namespace_definition" },
    template: { label: "模板定义", node: "template_declaration" },
    lambda: { label: "lambda 表达式", node: "lambda_expression" },
    using: { label: "using 声明", node: "using_declaration" },
  },
  Python: {
    for_loop: { label: "for 循环", node: "for_statement" },
    while_loop: { label: "while 循环", node: "while_statement" },
    if_statement: { label: "if 条件", node: "if_statement" },
    elif_clause: { label: "elif 子句", node: "elif_clause" },
    else_clause: { label: "else 子句", node: "else_clause" },
    break: { label: "break 语句", node: "break_statement" },
    continue: { label: "continue 语句", node: "continue_statement" },
    return: { label: "return 语句", node: "return_statement" },
    function_definition: { label: "函数定义", node: "function_definition" },
    class_definition: { label: "类定义", node: "class_definition" },
    assignment: { label: "赋值语句", node: "assignment" },
    try_except: { label: "try-except", node: "try_statement" },
    with_statement: { label: "with 语句", node: "with_statement" },
    import: { label: "import 语句", node: "import_statement" },
    import_from: { label: "from-import 语句", node: "import_from_statement" },
    list_comprehension: { label: "列表推导式", node: "list_comprehension" },
    list_literal: { label: "列表", node: "list" },
    dict_literal: { label: "字典", node: "dictionary" },
    set_literal: { label: "集合", node: "set" },
    /**
     * f-string 认的是 `interpolation`（`f"{x}"` 里的 `{x}`），不是 `format_string` ——
     * 这个版本的 tree-sitter-python 里**没有** format_string 这种节点，f-string 是
     * 一个 `string`，靠 `string_start` 为 `f"` 和内部的 interpolation 子节点来认。
     * 配成 format_string 的那阵子，「不能使用 f-string」从上线起就一直判成通过。
     *
     * 代价是 `f"abc"` 这种**没有占位符**的 f-string 认不出来（它确实不含
     * interpolation）。没占位符的 f-string 本来也没有意义，而且比起「一个都认不出来」
     * 这已经是严格的改善。实测 `%` 格式化、`.format()`、普通字符串、字符串拼接
     * 都不会误伤。
     */
    f_string: { label: "f-string", node: "interpolation" },
  },
}

/**
 * 运算符 target → 该语言里的实际写法。逻辑名 `and` / `or` / `not` 在 C 里写作
 * `&&` / `||` / `!`，文案要翻（否则 C 题的学生看到「必须使用 and 运算符」，而 C 里
 * 根本没有 `and` 这个词），判题机也正好拿同一个值去比节点类型 —— 所以这张表**一份
 * 两用**，不像节点那样需要两个字段。原来判题机的 mappings 里还抄了一份非恒等的
 * （`and`→`&&` 那三条），取值逐个相同，纯属重复。
 *
 * 恒等的条目（`+`、`==` …）写全是因为这张表同时是后台下拉的选项来源。
 */
const C_OPERATOR_TARGETS = {
  "+": "+",
  "-": "-",
  "*": "*",
  "/": "/",
  "%": "%",
  "+=": "+=",
  "-=": "-=",
  "*=": "*=",
  "/=": "/=",
  "%=": "%=",
  "++": "++",
  "--": "--",
  "==": "==",
  "!=": "!=",
  ">": ">",
  ">=": ">=",
  "<": "<",
  "<=": "<=",
  and: "&&",
  or: "||",
  not: "!",
  "&": "&",
  "|": "|",
}

export const AST_OPERATOR_TARGETS_BY_LANGUAGE: Record<string, Record<string, string>> = {
  C: C_OPERATOR_TARGETS,
  // `<<` / `>>` 对 C++ 主要是 cout/cin 的流运算符（位移是同一个 token）
  "C++": { ...C_OPERATOR_TARGETS, "<<": "<<", ">>": ">>" },
  Python: {
    "+": "+",
    "-": "-",
    "*": "*",
    "/": "/",
    "//": "//",
    "%": "%",
    "**": "**",
    "+=": "+=",
    "-=": "-=",
    "*=": "*=",
    "/=": "/=",
    "%=": "%=",
    "==": "==",
    "!=": "!=",
    ">": ">",
    ">=": ">=",
    "<": "<",
    "<=": "<=",
    and: "and",
    or: "or",
    not: "not",
    "&": "&",
    "|": "|",
  },
}

/**
 * 判题机真正能做 AST 检查的语言。设计文档写的是"支持全部 6 种语言"，落地的只有
 * 这两种 —— 其余语言 judge/ast.ts 的 loadLanguage 返回 null，规则一条都不会跑。
 * 所以后台不给别的语言开 tab，题目页也不把它们的规则展示成「要求」。
 */
export const AST_SUPPORTED_LANGUAGES = Object.keys(AST_NODE_TARGETS_BY_LANGUAGE)

/** 全语言的节点中文名并集，只给拿不到语言的场合做回落。有语言一律走 astNodeLabel() */
export const AST_NODE_TARGET_LABELS: Record<string, string> = Object.fromEntries(
  Object.values(AST_NODE_TARGETS_BY_LANGUAGE).flatMap((table) =>
    Object.entries(table).map(([target, entry]) => [target, entry.label]),
  ),
)

export function astNodeLabel(target: string, language?: string): string {
  const table = language ? AST_NODE_TARGETS_BY_LANGUAGE[language] : undefined
  return table?.[target]?.label ?? AST_NODE_TARGET_LABELS[target] ?? target
}

/**
 * target → tree-sitter 节点类型。判题机唯一的解析入口 ——
 * 节点走上面那张表的 `node`，运算符走运算符表（它的值本身就是要比的 token），
 * 都对不上就回落到裸 target（恒等的运算符 `+` / `==` 走的就是这条）。
 */
export function astTargetNodeType(target: string, language: string): string {
  return (
    AST_NODE_TARGETS_BY_LANGUAGE[language]?.[target]?.node ??
    AST_OPERATOR_TARGETS_BY_LANGUAGE[language]?.[target] ??
    target
  )
}

export function astOperatorLabel(target: string, language?: string): string {
  return (language ? AST_OPERATOR_TARGETS_BY_LANGUAGE[language]?.[target] : undefined) ?? target
}

/**
 * count_* 引擎至少要有一个数字约束，否则这条规则恒真 —— rangePassed 三个字段全
 * undefined 直接返回 true，描述也退化成光秃秃一个「for 循环」。编辑器切到
 * 「出现次数」时会清掉 exact/min/max，老师不填数字就会存出这种规则。
 *
 * 读取路径（判题、题目页要求）用它把这种规则整条丢掉，而不是让 schema 校验失败：
 * astRulesSchema 同时用于**读**后台题目详情，在那儿抛错会让整个详情打不开。
 */
export function astRuleIsMeaningful(rule: {
  engine: string
  exact?: number
  min?: number
  max?: number
}): boolean {
  if (!rule.engine.startsWith("count")) return true
  return rule.exact !== undefined || rule.min !== undefined || rule.max !== undefined
}

/**
 * 下发给**学生**的代码要求。只有渲染要用的两个字段 —— 文案由后端生成，
 * engine / target 这些内部字段不出现在响应里。
 *
 * 旧后端的 ProblemSerializer 没排掉 ast_rules，学生拿到的是规则原文；阶段 3
 * 泄露评审刻意收掉了它，同时写明「前端要读具体内容的话得补个专门的字段」——
 * 就是这个。收紧保留，展示恢复。
 */
export const astRequirementSchema = z.object({
  /** 已经渲染好的中文文案，例如「if 条件 出现 2 次」 */
  description: z.string(),
  /** 标签配色：必须做 / 不能做 / 次数约束 */
  kind: z.enum(["require", "forbid", "count"]),
})

/** 按语言分组，与 astRulesSchema 同一套键 */
export const astRequirementsSchema = z.record(z.string(), z.array(astRequirementSchema))

export const problemDetailSchema = z.object({
  id: z.number().int(),
  _id: z.string(),
  title: z.string(),
  description: z.string(),
  inputDescription: z.string(),
  outputDescription: z.string(),
  samples: z.array(
    z.object({
      input: z.string(),
      output: z.string(),
    }),
  ),
  hint: z.string().nullable(),
  languages: z.array(problemLanguageSchema),
  /**
   * 语言 → 代码模板。**用 partialRecord 让键受语言联合约束** ——
   * 原来这里是 `z.record(z.string(), z.string())`，等价于 `Record<string, string>`，
   * 前端按语言查模板时拿不到任何键名保护（`template["Pytho3"]` 也是合法表达式）。
   *
   * partialRecord 而非 record：没配模板的语言不该出现该键（`template: {}` 是常态），
   * 用 record 会要求每一个语言键都存在。
   */
  template: z.partialRecord(problemLanguageSchema, z.string()),
  createTime: z.string(),
  lastUpdateTime: z.string().nullable(),
  timeLimit: z.number().int(),
  memoryLimit: z.number().int(),
  difficulty: maskedProblemDifficultySchema,
  source: z.string().nullable(),
  prompt: z.string().nullable(),
  submissionNumber: z.number().int(),
  acceptedNumber: z.number().int(),
  statisticInfo: z.record(z.string(), z.unknown()),
  contestId: z.number().int().nullable(),
  tags: z.array(z.string()),
  createdBy: z.object({
    id: z.number().int(),
    username: z.string(),
    realName: z.string().nullable(),
  }),
  myStatus: z.number().int().nullable(),
  myFailedCount: z.number().int(),
  allowFlowchart: z.boolean(),
  showFlowchart: z.boolean(),
  mermaidCode: z.string().nullable(),
  flowchartData: z.record(z.string(), z.unknown()).nullable(),
  flowchartHint: z.string().nullable(),
  sqlConfig: sqlConfigSchema.nullable(),
  sqlDisplay: sqlDisplaySchema.nullable(),
  // 代码要求（AST 规则的展示投影）。规则原文不下发给学生，见 astRequirementSchema
  astRequirements: astRequirementsSchema.nullable(),
})

export type ProblemDetail = z.infer<typeof problemDetailSchema>

export const problemListItemSchema = z.object({
  id: z.number().int(),
  _id: z.string(),
  title: z.string(),
  submissionNumber: z.number().int(),
  acceptedNumber: z.number().int(),
  difficulty: maskedProblemDifficultySchema,
  createdBy: sampleUserSchema,
  tags: z.array(z.string()),
  contestId: z.number().int().nullable(),
  allowFlowchart: z.boolean(),
  showFlowchart: z.boolean(),
  hasAstRules: z.boolean(),
  /** SQL 题（可选语言里有 SQL）：写 SQL 语句查数据库，和写 C / Python 是两回事，列表里单独标出来 */
  isSql: z.boolean(),
  /** 0 = 做对了。画流程图的题，流程图评到 A / S 也给 0（和题单、课堂条一个口径） */
  myStatus: z.number().int().nullable(),
  /**
   * 做对的人 / 交过的人，和题目页「统计」页签同一个口径（代码提交、不算还在判的）。
   * 代替原来的提交数和按提交算的通过率：1044 按提交算只有 69%，按人算 817 / 826
   */
  solvedUsers: z.number().int(),
  triedUsers: z.number().int(),
})

export const problemListSchema = paginatedSchema(problemListItemSchema)

/** 题目列表「全部类型」下拉：SQL / 有参考图 / 画流程图 / 语法要求 */
export const problemTypeFilterSchema = z.enum(["sql", "reference", "flowchart", "ast"])

/**
 * 题目列表的排序。值沿用原来的（旧链接照样能用）：空串 = 最新创建、create_time = 最早创建，
 * ±submission_number / ±accepted_number 是做过 / 做对的**人数**，带 - 是从多到少
 */
export const problemListSortSchema = z.enum([
  "",
  "create_time",
  "-submission_number",
  "submission_number",
  "-accepted_number",
  "accepted_number",
])

/**
 * 题目列表顶上那行和左栏的进度。**只说做到了什么**：做对几道、这周新做对几道、
 * 离哪个成就最近；没做对的只给一个数（「有 n 道差一点」），不列出来。
 */
export const problemProgressSchema = z.object({
  /** 做对的题数，和成就的「AC 题目数」同一个数（不含比赛），这样「再做对 n 道」加得上 */
  solved: z.number().int(),
  /** 本周（东八区周一起）新做对几道 */
  weekSolved: z.number().int(),
  /** 连续几周都有新做对（到本周或上周为止；断了就是 0） */
  weekStreak: z.number().int(),
  /** 交过、还没做对的公开题。只在点「有 n 道差一点」时弹出来看，不常驻在页面上 */
  almost: z.array(z.object({ _id: z.string(), title: z.string() })),
  /** 标签 id → 这个标签下做对了几道（只数公开可见的题） */
  byTag: z.record(z.string(), z.number().int()),
  /** 离得最近的下一个成就；全拿到了、或者没有能提示的为 null */
  next: z
    .object({
      name: z.string(),
      icon: z.string(),
      rarity: achievementRaritySchema,
      metric: z.string(),
      threshold: z.number().int(),
      progress: z.number().int(),
    })
    .nullable(),
})

/**
 * 标签分两类：`knowledge` 是知识点（循环结构、字符串……），`theme` 是题目的
 * 题材（LOL、周杰伦、哈利波特……）。两类原来混在一起，题目列表上四十多个标签
 * 挤成一片，学生想按知识点找题得在一堆游戏名里挑。新标签默认算知识点。
 */
export const tagCategorySchema = z.enum(["knowledge", "theme"])

export const tagSchema = z.object({
  id: z.number().int(),
  name: z.string(),
  category: tagCategorySchema,
  problemCount: z.number().int().nonnegative(),
})

export const problemAuthorSchema = z.object({
  username: z.string(),
  problemCount: z.number().int().nonnegative(),
})

const failureCountSchema = z.object({ result: judgeStatusSchema, count: z.number().int() })

/**
 * 题目页「统计」页签。全部**按人**算，不按提交条数 —— 原来的「通过数」是 AC 条数
 * （3092 是 219 条、202 个人），「通过率」是按提交算的，学生看了不知道这题难不难。
 * 原来的「击败用户」（分母是近两年所有登录过的人）、饼图、历年 AC 率一起去掉了。
 */
export const problemStatsSchema = z.object({
  /** 比赛还没结束（又不是比赛管理员）：别人的情况一律不给，下面的数字都是 0 / 空 */
  locked: z.boolean(),
  /** 交过的人 */
  tried: z.number().int(),
  solved: z.number().int(),
  /** 做对的人用了几次：1 次 / 2–3 次 / 4 次以上 */
  tries: z.object({ one: z.number().int(), few: z.number().int(), many: z.number().int() }),
  /** 没通过的提交按结果分，多的在前（不含判题中） */
  failures: z.array(failureCountSchema),
  /** 我自己：交了几次、做对没有。没登录为 null */
  me: z.object({ attempts: z.number().int(), solved: z.boolean() }).nullable(),
  /** 学生自己班这题 x / y 人做对（y 是班里交过的人）。没班级、比赛里为 null */
  myClass: z
    .object({ className: z.string(), tried: z.number().int(), solved: z.number().int() })
    .nullable(),
  /**
   * 老师：各班做这道题的情况，和数据统计「按班级汇总」**同一个口径**（只算学生的提交；
   * 做完 / 班级人数、交了没对、没交、正确率、最近一次），交过的人多的在前。
   * 两边数字要一模一样 —— 老师从这里点过去，看到的数「变了」就不会再信任何一边。
   * 学生、比赛里为 null
   */
  classes: z
    .array(
      z.object({
        /** null = 没有班级的号（数据统计那边写「没有班级」） */
        className: z.string().nullable(),
        /** 班里的学生数（学生角色、没禁用）；没有班级的那一行就是交过的人数 */
        classSize: z.number().int(),
        solved: z.number().int(),
        /** 交了但没做对的人 */
        unsolved: z.number().int(),
        /** 班里还没交过的人 */
        untouched: z.number().int(),
        /** 提交正确率，分母不算还在判的；一条都没判完为 null */
        correctRate: z.number().nullable(),
        lastTime: z.string(),
      }),
    )
    .nullable(),
})

export type AstRuleEngine = z.infer<typeof astRuleEngineSchema>
export type AstRule = z.infer<typeof astRuleSchema>
export type AstRules = z.infer<typeof astRulesSchema>
export type AstRequirement = z.infer<typeof astRequirementSchema>
export type AstRequirements = z.infer<typeof astRequirementsSchema>
export type ProblemDifficulty = z.infer<typeof problemDifficultySchema>
export type ProblemListItem = z.infer<typeof problemListItemSchema>
export type ProblemList = z.infer<typeof problemListSchema>
export type ProblemTypeFilter = z.infer<typeof problemTypeFilterSchema>
export type ProblemListSort = z.infer<typeof problemListSortSchema>
export type ProblemProgress = z.infer<typeof problemProgressSchema>
export type Tag = z.infer<typeof tagSchema>
export type TagCategory = z.infer<typeof tagCategorySchema>
export type ProblemAuthor = z.infer<typeof problemAuthorSchema>
export type SqlConfig = z.infer<typeof sqlConfigSchema>
export type SqlDisplay = z.infer<typeof sqlDisplaySchema>
export type SqlDisplayTable = z.infer<typeof sqlDisplayTableSchema>
export type SqlDisplayColumn = z.infer<typeof sqlDisplayColumnSchema>
export type ProblemStats = z.infer<typeof problemStatsSchema>