// 确保存在如下的状态模型
export type AppState = {
    todos: Todo[];
    currentUser: User[] | null; // 用户可能存在，也可能未登录
    currentFilter: Filter;
}``

import { Todo, AppState, Filter } from './types'; // 引入 AppState

// ... state 定义 (请确保 state 符合 AppState 类型)
const state: AppState = {
  // ...
};

// ... 其他函数 函数 ...

// “天真”的 updateTodo 函数
function updateTodo(id: number, updatedTodo: Todo): void {
  const todoToUpdate = state.todos.find(todo => todo.id === id);
  if (todoToUpdate) {
    // 通过传入进来的新对象合并我们的旧对象
    Object.assign(todoToUpdate, updatedTodo);
  }
}

// 场景：只想把 id 为 2 的 todo 标记为完成
const todoToUpdate = findItemById(state.todos, 2);

if (todoToUpdate) {
  // 痛点来了！
  // 为了只修改 `completed` 属性，我们却被迫传入一个完整的 Todo 对象，
  // 甚至不得不把旧的 `text` 和 `id` 也带上。
  updateTodo(2, {
    ...todoToUpdate,
    completed: true
  });
}

// ... 其他代码 ...

// 重构后的 updateTodo 函数
// 我们将第二个参数的类型从 Todo 改为 Partial <Todo>
function updateTodo(id: number, payload: Partial<Todo>): void {
  const todoToUpdate = state.todos.find(todo => todo.id === id);
  if (todoToUpdate) {
    // payload 中有什么属性，就更新什么属性
    Object.assign(todoToUpdate, payload);
    console.log(`新更新的state.todos ${JSON.stringify(state.todos)}`);
  }
}

// 现在，调用变得无比优雅和精确
updateTodo(2, { completed: true }); // 只想更新 completed，就只传 completed
updateTodo(1, { text: "学习 TypeScript 高级类型" }); // 只更新 text

import { Todo } from './types';

// 使用 keyof 获取 Todo 接口的所有键
type TodoKeys = keyof Todo; 

// 鼠标悬停在 TodoKeys 上，你会看到它的类型是：
// "id" | "text" | "completed" | "dueDate"

let key: TodoKeys = "text"; // 正确
// key = "description"; // 错误: "description" 不在 TodoKeys 联合类型中

// ... 其他类型 ...

// 使用 Pick 创建一个只包含 text 和 completed 的“预览”类型
export type TodoPreview = Pick<Todo, "text" | "completed">;

function renderTodoPreview(preview: TodoPreview): void {
  console.log(`[预览] ${preview.text} - ${preview.completed ? '已完成' : '未完成'}`);
  // 这一行就会编译错误了
  // console.log(preview.id);
}

const todo = findItemById(state.todos, 1);
if (todo) {
  // preview 对象上没有 id 属性，访问会导致编译错误
  // 但是我没呢 findItemById 是返回的一个完整的 todo 对象，所以他是可以访问 id 属性的
  renderTodoPreview(todo);
}

// 定义一个条件类型
type Processable = string | number;
type ProcessResult<T> = T extends Processable ? T : never;

function process<T>(value: T): ProcessResult<T> {
  if (typeof value === 'string' || typeof value === 'number') {
    return value as ProcessResult<T>;
  }
  throw new Error("Invalid value");
}

let result1 = process("hello"); // result1 的类型是 string
let result2 = process(123);     // result2 的类型是 number
// let result3 = process(true);    // 编译错误！因为 ProcessResult <boolean> 是 never

function addTodo(text: string, dueDate?: Date): number {
  const newTodo: Todo = {
    id: Date.now(),
    text,
    completed: false,
    dueDate
  };
  state.todos.push(newTodo);
  return newTodo.id;
}

// 捕获 addTodo 函数的参数类型
type AddTodoParams = Parameters<typeof addTodo>;
// AddTodoParams 的类型是: [text: string, dueDate?: Date | undefined]

// 捕获 addTodo 函数的返回类型
type AddTodoReturn = ReturnType<typeof addTodo>;
// AddTodoReturn 的类型是: number

// F 必须是一个函数类型
export function logFunctionCall<F extends (...args: any[]) => any>(
  fn: F, 
  ...args: Parameters<F> // ...args 的类型被精确地定义为 F 的参数类型
): ReturnType<F> { // 返回值类型被精确地定义为 F 的返回类型
  
  console.log(`${fn.name} 被调用，参数:`, ...args);
  const result = fn(...args);
  console.log(`${fn.name} 返回:`, result);
  
  return result;
}

import { logFunctionCall } from './utils';
// ...

// 使用 logFunctionCall 来包装 addTodo
const newId = logFunctionCall(addTodo, "完成第四章笔记");

// 尝试使用错误的参数类型，会立刻得到编译时错误！
// logFunctionCall(addTodo, 123); // 错误: 类型“number”的参数不能赋给类型“string”的参数。