import { createQueryApi } from '../src/query-api.ts';

// ============ 示例 1: 基础 JSON Schema 推断 ============
const api1 = {
  "user": {
    "get": {
      "path": "user",
      "key": "get",
      "metadata": {
        "args": {
          "userId": {
            "type": "string"
          },
          "includeProfile": {
            "type": "boolean"
          }
        }
      }
    }
  }
} as const;

const queryApi1 = createQueryApi({ api: api1 });

// ✅ 类型推断正常工作
queryApi1.user.get({
  userId: '123',          // ✅ 推断为 string
  includeProfile: true    // ✅ 推断为 boolean
});

// ❌ TypeScript 会报错
// queryApi1.user.get({
//   userId: 123,  // 错误：应该是 string
//   wrongProp: 'test'  // 错误：不存在的属性
// });


// ============ 示例 2: 嵌套对象 JSON Schema（你的场景）============
const api2 = {
  "app_domain_manager": {
    "get": {
      "path": "app_domain_manager",
      "key": "get",
      "metadata": {
        "args": {
          "data": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "domain": {
                "type": "string"
              }
            }
          }
        }
      }
    }
  }
} as const;

const queryApi2 = createQueryApi({ api: api2 });

// ✅ 类型推断正常工作 - data 参数被推断为 { id: string, domain: string }
queryApi2.app_domain_manager.get({
  data: {
    id: '123',
    domain: 'example.com'
  }
});

// ❌ TypeScript 会报错
// queryApi2.app_domain_manager.get({
//   data: {
//     wrongProp: 'test'  // 错误：不存在的属性
//   }
// });


// ============ 示例 3: 复杂嵌套结构 ============
const api3 = {
  "product": {
    "create": {
      "path": "product",
      "key": "create",
      "metadata": {
        "args": {
          "product": {
            "type": "object",
            "properties": {
              "name": { "type": "string" },
              "price": { "type": "number" },
              "tags": {
                "type": "array",
                "items": { "type": "string" }
              },
              "metadata": {
                "type": "object",
                "properties": {
                  "color": { "type": "string" },
                  "size": { "type": "string" }
                }
              }
            }
          }
        }
      }
    }
  }
} as const;

const queryApi3 = createQueryApi({ api: api3 });

// ✅ 复杂嵌套类型推断
queryApi3.product.create({
  product: {
    name: 'T-Shirt',
    price: 29.99,
    tags: ['clothing', 'summer'],
    metadata: {
      color: 'blue',
      size: 'M'
    }
  }
});


// ============ 示例 4: 枚举类型 ============
const api4 = {
  "order": {
    "updateStatus": {
      "path": "order",
      "key": "updateStatus",
      "metadata": {
        "args": {
          "orderId": { "type": "string" },
          "status": {
            "type": "string",
            "enum": ["pending", "processing", "shipped", "delivered"] as const
          }
        }
      }
    }
  }
} as const;

const queryApi4 = createQueryApi({ api: api4 });

// ✅ 枚举类型推断
queryApi4.order.updateStatus({
  orderId: 'ORD-123',
  status: 'shipped'  // ✅ 自动提示: "pending" | "processing" | "shipped" | "delivered"
});

// ❌ TypeScript 会报错
// queryApi4.order.updateStatus({
//   orderId: 'ORD-123',
//   status: 'invalid-status'  // 错误：不在枚举值中
// });


console.log('✅ 所有类型推断示例运行成功！');