/**
 * 乐观更新工具函数
 * 用于统一管理乐观更新逻辑，减少重复代码
 */

export interface OptimisticUpdateOptions<T, R> {
  /** 获取当前状态 */
  getState: () => T;
  /** 执行乐观更新 */
  optimisticUpdate: (current: T) => T;
  /** API调用函数 */
  apiCall: () => Promise<R>;
  /** API成功时的回调，返回新的状态 */
  onSuccess?: (result: R, current: T) => T;
  /** API失败时的回滚回调 */
  onError?: (error: any, original: T) => T;
  /** 错误消息 */
  errorMessage?: string;
  /** 是否静默处理错误（不抛出） */
  silent?: boolean;
}

/**
 * 执行乐观更新
 * 
 * 流程：
 * 1. 保存原始状态
 * 2. 执行乐观更新
 * 3. 调用API
 * 4. 成功时使用服务器数据更新状态
 * 5. 失败时回滚到原始状态
 * 
 * @template T 状态类型
 * @template R API返回类型
 * @param options 配置选项
 * @returns Promise<R> API返回结果
 */
export async function optimisticUpdate<T, R>(
  options: OptimisticUpdateOptions<T, R>
): Promise<R | undefined> {
  const {
    getState,
    optimisticUpdate,
    apiCall,
    onSuccess,
    onError,
    errorMessage = '操作失败',
    silent = true,
  } = options;

  // 保存原始状态
  const originalState = getState();

  // 执行乐观更新
  const optimisticState = optimisticUpdate(originalState);

  try {
    // 调用API
    const result = await apiCall();

    // API成功，使用服务器数据更新状态（如果提供了onSuccess）
    if (onSuccess) {
      onSuccess(result, optimisticState);
    }

    return result;
  } catch (error) {
    console.error(`${errorMessage}:`, error);

    // API失败，回滚状态
    if (onError) {
      onError(error, originalState);
    }

    // 如果不是静默模式，抛出错误
    if (!silent) {
      throw error;
    }

    return undefined;
  }
}

/**
 * 简化版的乐观更新（适用于不需要服务器返回数据的场景）
 * 
 * @template T 状态类型
 * @param options 配置选项
 */
export async function simpleOptimisticUpdate<T>(
  options: Omit<OptimisticUpdateOptions<T, void>, 'onSuccess' | 'onError'> & {
    setState: (state: T) => void;
    rollbackState: (original: T) => T;
  }
): Promise<void> {
  const {
    getState,
    setState,
    optimisticUpdate,
    rollbackState,
    apiCall,
    errorMessage = '操作失败',
    silent = true,
  } = options;

  // 保存原始状态
  const originalState = getState();

  // 执行乐观更新
  setState(optimisticUpdate(originalState));

  try {
    // 调用API
    await apiCall();
  } catch (error) {
    console.error(`${errorMessage}:`, error);

    // API失败，回滚状态
    setState(rollbackState(originalState));

    // 如果不是静默模式，抛出错误
    if (!silent) {
      throw error;
    }
  }
}

/**
 * 创建乐观更新器（用于Zustand store）
 * 
 * 使用方式：
 * ```typescript
 * const createOptimisticUpdater = createOptimisticUpdaterFactory(set, get);
 * 
 * const likePost = async (postId: string) => {
 *   await createOptimisticUpdater({
 *     getCurrentState: () => get().posts,
 *     setState: (posts) => set({ posts }),
 *     optimisticUpdate: (posts) => posts.map(...),
 *     rollbackState: (originalPosts) => originalPosts,
 *     apiCall: () => postService.likePost(postId),
 *     errorMessage: '点赞失败',
 *   });
 * };
 * ```
 */
export function createOptimisticUpdaterFactory<T extends Record<string, any>>(
  set: (fn: (state: T) => T) => void,
  get: () => T
) {
  return function optimisticUpdater<K extends keyof T>(
    options: {
      key: K;
      optimisticUpdate: (current: T[K]) => T[K];
      rollbackState: (original: T[K]) => T[K];
      apiCall: () => Promise<any>;
      errorMessage?: string;
      silent?: boolean;
    }
  ): Promise<void> {
    const {
      key,
      optimisticUpdate,
      rollbackState,
      apiCall,
      errorMessage = '操作失败',
      silent = true,
    } = options;

    // 保存原始状态
    const originalState = get()[key];

    // 执行乐观更新
    set((state) => ({
      ...state,
      [key]: optimisticUpdate(state[key]),
    }));

    return new Promise((resolve, reject) => {
      apiCall()
        .then(() => {
          resolve();
        })
        .catch((error) => {
          console.error(`${errorMessage}:`, error);

          // 回滚状态
          set((state) => ({
            ...state,
            [key]: rollbackState(originalState),
          }));

          if (silent) {
            resolve();
          } else {
            reject(error);
          }
        });
    });
  };
}
