// 我们之前定义的 Todo 和 Filter 类型也移到这里
export interface Todo {
    readonly id: number;
    text: string;
    completed: boolean;
    dueDate?: Date;
}

export type Filter = "all" | "active" | "completed";

// 新增 User 接口
export interface User {
    id: number;
    name: string;
    email: string;
}

export type AppState = {
    todos: Todo[];
    currentUser: User[] | null; // 用户可能存在，也可能未登录
    currentFilter: Filter;
}

import './style.css';
// 从 types.ts 导入类型
import type { Todo, User, AppState, Filter } from './types';

const state: AppState = {
  todos: [
    { id: 1, text: "学习 TypeScript 核心类型", completed: true },
    { id: 2, text: "编写一个 Todo List 应用", completed: false },
  ],
  currentUser: { id: 1, name: "Prorise", email: "contact@prorise.com" },
  currentFilter: "all"
};

function findTodoById(id: number): Todo | undefined {
  return state.todos.find(todo => todo.id === id);
}

function findUserById(id: number): User | undefined {
  // 假设我们有一个用户列表
  const users: User[] = [state.currentUser!]; 
  return users.find(user => user.id === id);
}

function findItemById_any(items: any[], id: number): any {
  return items.find(item => item.id === id);
}

const foundTodo = findItemById_any(state.todos, 1);

// 灾难发生：
// 1. 类型丢失：foundTodo 的类型是 any，我们失去了所有代码提示。
// 2. 运行时风险：我们可以调用任何不存在的方法，编译器不会警告我们。
//    这行代码可以通过编译，但在运行时会因为 toUpperCase 不存在而崩溃。
console.log(foundTodo.text.toUpperCase()); 

// T 是一个类型变量，一个“占位符”。
// 这个函数接收一个 T 类型的数组和一个 number 类型的 id，
// 并返回一个 T 类型的值或 undefined。
export function findItemById<T>(items: T[], id: number): T | undefined {
  // 这里会出现一个编译错误，这是我们下一步要解决的
  return items.find(item => item.id === id); 
}

// 我们约束 T 必须是这样一个对象：它至少要有一个 number 类型的 id 属性。
export function findItemById<T extends { id: number }>(items: T[], id: number): T | undefined {
  // 现在 TypeScript 知道 item 上一定有 id 属性，错误消失了。
  return items.find(item => item.id === id);
}

import './style.css';
// 从 types.ts 导入类型
import type { Todo, User, AppState, Filter } from './types';
import { findItemById } from './utils'; // 导入我们的泛型函数

const state: AppState = {
  todos: [
    { id: 1, text: "学习 TypeScript 核心类型", completed: true },
    { id: 2, text: "编写一个 Todo List 应用", completed: false },
  ],
  currentUser: [
    { id: 1, name: "Prorise", email: "contact@prorise.com" },
    { id: 2, name: "John", email: "john@example.com" },
  ],
  currentFilter: "all"
};

// 调用泛型函数
// 1. 查找 Todo
const todo = findItemById(state.todos, 1);
// todo 的类型被正确推断为 Todo | undefined，拥有 text, completed 等属性

console.log(todo?.text);

// 2. 查找 User
const user = findItemById(state.currentUser!, 1);

console.log(user?.name);

// ... 其他类型定义 ...

// 定义一个通用的 API 响应“包装器”
// T 代表了 `data` 属性中具体的数据类型
export interface ApiResponse<T> {
  status: number;
  message: string;
  data: T;
}

import { Todo, User, ApiResponse } from './types';

// 模拟 API 地址
const API_BASE = "https://api.example.com";

// 获取 Todo 列表的函数
// 它的返回值是一个 Promise，Promise 的解析值符合 ApiResponse <Todo[]> 契约
export async function fetchTodos(): Promise<ApiResponse<Todo[]>> {
  // 实际项目中这里是真实的 fetch 调用
  // return fetch(`${API_BASE}/todos`).then(res => res.json());
  
  // 此处为模拟数据
  return Promise.resolve({
    status: 200,
    message: "Success",
    data: [
      { id: 1, text: "从 API 获取 Todo", completed: false }
    ]
  });
}

// 获取单个用户的函数
export async function fetchUser(id: number): Promise<ApiResponse<User>> {
    return Promise.resolve({
        status: 200,
        message: "Success",
        data: { id, name: "API User", email: "api@example.com" }
    });
}