import { z } from 'zod';

// 定义 schema — 同时是类型源头和运行时校验器
const UserSchema = z.object({
  name: z.string().min(2).max(20),
  age: z.number().int().positive(),
  email: z.email(),
});

// 推导 TypeScript 类型（编译时）
type User = z.infer<typeof UserSchema>;
//    ^? { name: string; age: number; email: string }

// 运行时校验 — 拦截非法数据
const result = UserSchema.safeParse({ name: 'A', age: -1, email: 'bad' });
//    ^? { success: false, error: ZodError }
// result.error.issues → [
//   { path: ['name'], message: 'Invalid input: expected string, received number' }
//   ...
// ]

const n1 = z.string();
// n1 → ZodString { _def: { type: 'string' } }

const n2 = n1.min(2);
// n2 → ZodString { _def: { type: 'string', checks: [ $ZodCheckMinLength {} ] } }

n1 === n2  // false — n1 没变，n2 是全新实例

z.string()
z.number()
z.bigint()
z.boolean()
z.date()
z.nan()
z.undefined()
z.null()
z.void()
z.never()
z.unknown()
z.any()

z.object({ name: z.string(), age: z.number() })

z.strictObject({ name: z.string() })   // 显式禁止未知属性，等同于 z.object().strict()
z.looseObject({ name: z.string() })    // 保留未知属性（透传），等同于 z.object().passthrough()
z.record(z.number())                   // → Record<string, number>

z.array(z.string())                  // → string[]
z.tuple([z.string(), z.number()])    // → [string, number]  定长定类型

z.union([z.string(), z.number()])    // → string | number
z.enum(['a', 'b', 'c'])             // → 'a' | 'b' | 'c'
z.literal('hello')                   // → 'hello'（精确字面量类型）

const ToolResult = z.discriminatedUnion('type', [
  z.object({ type: z.literal('weather'), temperature: z.number(), city: z.string() }),
  z.object({ type: z.literal('search'), results: z.array(z.string()), query: z.string() }),
  z.object({ type: z.literal('error'), message: z.string(), code: z.number() }),
]);

// type: 'weather' → 匹配第一个 schema
ToolResult.parse({ type: 'weather', temperature: 25, city: 'Beijing' });
// → { type: 'weather', temperature: 25, city: 'Beijing' }

// type: 'unknown' → 没有匹配的 schema
ToolResult.safeParse({ type: 'unknown' });
// → { success: false, error: 'Invalid discriminator value. Expected "weather" | "search" | "error"' }

type Category = z.infer<typeof CategorySchema>;

const CategorySchema: z.ZodType<Category> = z.object({
  name: z.string(),
  subcategories: z.lazy(() => CategorySchema.array()),
});

CategorySchema.parse({
  name: '电子产品',
  subcategories: [
    { name: '手机', subcategories: [] },
    { name: '电脑', subcategories: [
      { name: '笔记本', subcategories: [] },
    ]},
  ],
});

// 字符串 — 格式校验
z.string().email().url().uuid().ip().datetime()

// 字符串 — 长度与内容
z.string().min(2).max(100).length(10)
  .startsWith('https://').endsWith('.com').includes('needle')

// 字符串 — 变换
z.string().trim().toLowerCase()

// 数字
z.number().int().positive().min(0).max(100).multipleOf(5).finite()

// 元数据（不影响校验，toJSONSchema 时输出）
z.string().describe('字段说明')

// .refine() — 返回 true/false，适合单字段校验
const passwordSchema = z.string()
  .refine(val => val.length >= 8, '密码至少 8 位')
  .refine(val => /[A-Z]/.test(val), '密码必须包含大写字母')
  .refine(val => /[0-9]/.test(val), '密码必须包含数字');

// .superRefine() — 可添加多条 issue、自定义 error code，适合跨字段校验
const userSchema = z.object({
  password: z.string(),
  confirmPassword: z.string(),
}).superRefine((data, ctx) => {
  if (data.password !== data.confirmPassword) {
    ctx.addIssue({
      code: z.ZodIssueCode.custom,
      path: ['confirmPassword'],
      message: '两次密码不一致',
    });
  }
});

z.string().optional()   // 字段可选，等同 string | undefined
z.string().nullable()   // 字段可为 null，等同 string | null
z.string().nullish()    // 可选且可为 null，等同 string | undefined | null
z.string().default('default')  // 缺失时使用默认值，输出类型去掉 undefined

// URL query / form 传过来的全是字符串
const input = { age: '25', active: 'true', price: '9.99' };

const schema = z.object({
  age: z.coerce.number(),      // Number('25') → 25
  active: z.coerce.boolean(),  // Boolean('true') → true
  price: z.coerce.number(),    // Number('9.99') → 9.99
});

schema.parse(input);
// → { age: 25, active: true, price: 9.99 }

z.string().catch('fallback').parse(42);       // → 'fallback'
z.number().catch(0).parse('not a number');    // → 0

// catch + default 组合覆盖两种缺失场景
z.string().catch('fallback').default('default')
// undefined → 'default'（.default() 处理缺失）
// 42 → 'fallback'（.catch() 处理无效值）

// 抛错模式
schema.parse(data)

// 安全模式（推荐）
const r = schema.safeParse(data);
if (!r.success) {
  r.error.issues  // 错误列表
} else {
  r.data          // 类型安全的数据
}

.parse(data)     → 校验通过返回数据，不通过 throw ZodError
.safeParse(data) → 通过返回 { success: true, data }，不通过返回 { success: false, error: ZodError }

const result = schema.safeParse({ name: 'A', age: -1, email: 'bad' });
if (!result.success) {
  // 1. error.issues — 原始数组，包含 path / code / message 等完整信息
  result.error.issues
  // → [{ path: ['name'], code: 'too_small', message: '...' }, ...]

  // 2. flattenError() — 扁平结构，适合表单场景
  z.flattenError(result.error)
  // → { formErrors: [], fieldErrors: { name: ['...'], age: ['...'] } }

  // 3. treeifyError() — 树形结构，按层级组织
  z.treeifyError(result.error)
  // → { errors: [], properties: { name: { errors: ['...'] } } }

  // 4. formatError() — ⚠ 已废弃，用 treeifyError() 替代
  z.formatError(result.error)
  // → { _errors: [], name: { _errors: ['...'] } }

  // 5. prettifyError() — 可读字符串，适合日志和 CLI
  z.prettifyError(result.error)
  // → "✖ Too small: expected string to have >=2 characters\n  → at name\n..."
}

type T = z.infer<typeof schema>;
//       ^^^^^^^^  ^^^^^^^^^^^^^
//       类型名     泛型参数（typeof 从变量提取类型）

// Zod 源码（简化版）
export const z = {
  string: () => new ZodString(),
  number: () => new ZodNumber(),
  object: (shape) => new ZodObject(shape),
  // ... 值空间（运行时存在）
};

export namespace z {
  export type infer<T> = T['_output'];
  export type input<T> = T['_input'];
  export type output<T> = T['_output'];
  // ... 类型空间（编译后消失）
}

// src/v4/core/core.ts:117-120
export type input<T> = T extends { _zod: { input: any } } ? T["_zod"]["input"] : unknown;
export type output<T> = T extends { _zod: { output: any } } ? T["_zod"]["output"] : unknown;
export type { output as infer };  // infer 就是 output 的别名

// 1. 定义 schema
const UserSchema = z.object({ name: z.string(), age: z.number() });

// 2. 用 infer 提取类型（编译时）
type User = z.infer<typeof UserSchema>;

// 3. 用 parse 验证数据（运行时）
function createUser(data: unknown): User {
  return UserSchema.parse(data);  // ← 运行时验证，返回类型安全的值
}

// 4. 用 User 类型做其他事
const users: User[] = [];
function processUser(user: User): void { ... }

import { z, toJSONSchema } from 'zod';

const schema = z.object({
  location: z.string().describe('City name'),
  units: z.enum(['celsius', 'fahrenheit']).default('celsius'),
});

const jsonSchema = toJSONSchema(schema);
// → {
//     "type": "object",
//     "properties": {
//       "location": { "type": "string", "description": "City name" },
//       "units": { "type": "string", "enum": ["celsius", "fahrenheit"], "default": "celsius" }
//     },
//     "required": ["location", "units"],
//     "additionalProperties": false
//   }

// 字符串 → 数字
const numSchema = z.string()
  .transform(val => parseInt(val, 10));
// z.infer<typeof numSchema> → number（输入是 string，输出是 number）

// 字符串 → Date
const dateSchema = z.string()
  .refine(val => !isNaN(Date.parse(val)), '无效日期')
  .transform(val => new Date(val));
// z.infer<typeof dateSchema> → Date

// 链式：先 trim 再转小写
const emailSchema = z.string()
  .transform(val => val.trim().toLowerCase())
  .pipe(z.string().email());

// query string 逗号分隔 → 数字数组
const numArray = z.preprocess(
  val => typeof val === 'string' ? val.split(',').map(Number) : val,
  z.array(z.number()),
);
numArray.parse('1,2,3');  // → [1, 2, 3]

// 空字符串 → undefined（配合 optional 使用）
const optionalString = z.preprocess(
  val => val === '' ? undefined : val,
  z.string().optional(),
);
optionalString.parse('');       // → undefined
optionalString.parse('hello');  // → 'hello'

// 例 1：先验证是字符串，再转成数字
z.string().pipe(z.coerce.number())
// 输入: "123" → 输出: 123

// 例 2：先 trim，再验证 email 格式
z.string()
  .transform(s => s.trim())
  .pipe(z.string().email())
// 输入: "  test@example.com  " → 输出: "test@example.com"

// ❌ 这样写会报错
z.string()
  .transform(s => s.trim())  // 返回 ZodPipe，不再是 ZodString
  .min(3)                    // ← 没有 .min() 方法！

// ✅ 必须用 .pipe() 交给新的 schema
z.string()
  .transform(s => s.trim())
  .pipe(z.string().min(3))   // ← 新的 ZodString，有 .min()

// 纯链式就够了，不需要 pipe
z.string().min(3).max(100).email()

const UserSchema = z.object({
  id: z.string(),
  name: z.string(),
  email: z.string().email(),
  age: z.number(),
});

// .pick() — 只保留指定字段
const NameOnly = UserSchema.pick({ name: true, email: true });
// → { name: string, email: string }

// .omit() — 排除指定字段
const NoId = UserSchema.omit({ id: true });
// → { name: string, email: string, age: number }

// .partial() — 所有字段变可选
const Partial = UserSchema.partial();
// → { id?: string, name?: string, email?: string, age?: number }

// .extend() — 追加字段
const Extended = UserSchema.extend({ role: z.string() });
// → { id, name, email, age, role }

// .merge() — 合并两个 object schema
const AddressSchema = z.object({ city: z.string(), zip: z.string() });
const Merged = UserSchema.merge(AddressSchema);
// → { id, name, email, age, city, zip }

// 模拟异步校验（查数据库用户名是否已存在）
const checkUsernameExists = async (username: string) => {
  const taken = ['admin', 'root', 'test'];
  return taken.includes(username);
};

const schema = z.object({
  username: z.string().min(3),
  email: z.string().email(),
}).refine(async (data) => {
  const exists = await checkUsernameExists(data.username);
  return !exists;
}, { message: '用户名已被占用', path: ['username'] });

// 必须用 safeParseAsync，不能用 safeParse
const result = await schema.safeParseAsync({ username: 'admin', email: 'a@b.com' });
// → { success: false, error: { issues: [{ path: ['username'], message: '用户名已被占用' }] } }

src/v4/
├── core/          # zod/v4/core — 核心层
│   ├── core.ts    # $ZodType 基类，定义 schema 最小接口
│   ├── schemas.ts # 所有 schema 类型（ZodString / ZodNumber / ZodObject ...）
│   ├── parse.ts   # 解析引擎：深度优先遍历 schema 树，执行校验
│   ├── checks.ts  # 内置校验规则（min / max / email / regex / int ...）
│   ├── errors.ts  # ZodError / ZodIssue 错误系统
│   └── ...
├── classic/       # 用户日常使用的 API 层
│   └── schemas.ts # 在 core 之上包装链式 API（z.string().min() 等语法糖）
├── mini/          # zod/v4/mini — 可摇树优化的轻量版
└── locales/       # 国际化错误消息

core/$ZodType （最小接口：_parse / safeParse / 类型定义）
        ↑
classic/ZodType （加链式 API：.min() .max() .email() .default() ...）
        ↑
用户代码：z.object({ name: z.string().min(2) })

z.string().min(2).max(20)._def
// → { type: 'string', checks: [ $ZodCheckMinLength {}, $ZodCheckMaxLength {} ] }

z.number().int().positive()._def
// → { type: 'number', checks: [ ZodNumberFormat { format: 'safeint' }, $ZodCheckGreaterThan {} ] }

z.object({ name: z.string() })._def
// → { type: 'object', shape: { name: ZodString } }

z.string()              // checks: []                               — 无校验
  .min(2)               // checks: [ $ZodCheckMinLength ]            — 一条规则
  .max(20)              // checks: [ $ZodCheckMinLength, $ZodCheckMaxLength ]  — 两条
  .email()              // checks: [...前两条, ZodEmail ]             — 三条

const strSchema = z.string();
// strSchema 是 ZodString 实例，_def 存了 { type: 'string' }

const objSchema = z.object({
  name: z.string(),
  age: z.number().int(),
});
// objSchema 是 ZodObject 实例
// _def.shape 存了 { name: ZodString, age: ZodNumber }

ZodObject
  ├── shape.name  → ZodString   { type: 'string' }
  └── shape.age   → ZodNumber   { type: 'number', checks: [...] }

schema.parse(data)
// 1. 根节点（ZodObject）：遍历 shape 的每个 key
//     ↓
// 2. name 节点（ZodString）：遍历 checks 数组
//       逐个执行：min(2) 通过？max(20) 通过？...
//       不通过 → 记下 ZodIssue { path: ['name'], ... }
//     ↓
// 3. age 节点（ZodNumber）：遍历 checks 数组
//       逐个执行：int 通过？positive 通过？...
//       不通过 → 记下 ZodIssue { path: ['age'], ... }
//     ↓
// 4. 所有节点检查完毕
//      有错误 → throw ZodError（issues 数组包含所有问题）
//      无错误 → 返回传入的数据

// ① 模块加载时：创建 schema 实例（不验证）
const weatherTool = createTool({
  inputSchema: z.object({ location: z.string() }),
  // ...
});

// ② 用户调用 tool 时：框架内部做验证
// 框架源码大致是这样：
async function executeTool(tool, userInput) {
  const validated = tool.inputSchema.parse(userInput);  // ← 这里才真正验证
  return tool.execute(validated);
}

// API 路由 — 你自己写验证
app.post('/user', (req, res) => {
  const result = UserSchema.safeParse(req.body);  // ← 手动触发
  if (!result.success) {
    return res.status(400).json(result.error.issues);
  }
  db.user.create({ data: result.data });
});

// 表单提交 — 你自己写验证
function handleSubmit(formData: FormData) {
  const data = Object.fromEntries(formData);
  const result = FormSchema.safeParse(data);  // ← 手动触发
  if (!result.success) {
    showErrors(result.error.issues);
    return;
  }
  submit(result.data);
}

// ❌ ZodPipe 没有 .min() 方法
z.string().transform(s => s.trim()).min(3)

// ✅ 用 .pipe() 接入新 schema
z.string().transform(s => s.trim()).pipe(z.string().min(3))

// ❌ 报错
schema.safeParse(data)

// ✅
await schema.safeParseAsync(data)

// ❌ fetch 响应只靠类型断言，运行时无保护
const data = await fetch('/api/users').then(r => r.json()) as User[];

// ✅ 跨信任边界走 Zod 校验
const data = UserArraySchema.parse(await fetch('/api/users').then(r => r.json()));

z.coerce.boolean().parse('false')  // → true！（非空字符串都是 truthy）
z.coerce.boolean().parse('')       // → false
// Boolean('false') === true，只有 Boolean('') === false

// ❌ discriminator 用了 z.string()，TypeScript 无法收窄类型
z.discriminatedUnion('type', [
  z.object({ type: z.string(), ... })
])

// ✅ 必须用 z.literal()
z.discriminatedUnion('type', [
  z.object({ type: z.literal('weather'), ... })
])

// ❌ .refine() 无法指定错误路径到具体字段
z.object({ password: z.string(), confirm: z.string() })
  .refine(data => data.password === data.confirm, '密码不一致')

// ✅ .superRefine() 可以精确控制 addIssue() 的 path
z.object({ password: z.string(), confirm: z.string() })
  .superRefine((data, ctx) => {
    if (data.password !== data.confirm) {
      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['confirm'], message: '两次密码不一致' });
    }
  })

const schema = z.object({ name: z.string().min(2) });
// ↑ 这里什么都没验证，只是创建了一个配置对象
// 验证只发生在 .parse() / .safeParse() 调用时