// 创建查询客户端实例
const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 60000,  // 数据保鲜时间（毫秒）
      gcTime: 300000,    // 垃圾回收时间（Garbage Collection Time）
    },
  },
})

// 内部执行过程 (简化)
class QueryClient {
  #queryCache: QueryCache
  #mutationCache: MutationCache
  #defaultOptions: DefaultOptions
  #queryDefaults: Map<string, QueryDefaults>
  #mutationDefaults: Map<string, MutationDefaults>
  #mountCount: number
  // 用于自动重新获取机制的订阅清理函数
  #unsubscribeFocus?: () => void
  #unsubscribeOnline?: () => void

  constructor(config = {}) {
    this.#queryCache = config.queryCache || new QueryCache()
    this.#mutationCache = config.mutationCache || new MutationCache()
    this.#defaultOptions = config.defaultOptions || {}
    this.#queryDefaults = new Map()
    this.#mutationDefaults = new Map()
    this.#mountCount = 0
  }

  // 挂载时订阅焦点和网络状态变化
  mount(): void {
    this.#mountCount++
    if (this.#mountCount !== 1) return

    // 窗口重新聚焦时自动重新获取数据
    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {
      if (focused) {
        await this.resumePausedMutations()
        this.#queryCache.onFocus()
      }
    })
    // 网络恢复时自动重新获取数据
    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {
      if (online) {
        await this.resumePausedMutations()
        this.#queryCache.onOnline()
      }
    })
  }

  // 卸载时清理订阅
  unmount(): void {
    this.#mountCount--
    if (this.#mountCount !== 0) return
    this.#unsubscribeFocus?.()
    this.#unsubscribeOnline?.()
  }

  // ... 其他方法 (省略)
}

// 创建查询观察者
const observer = new QueryObserver(queryClient, {
  queryKey: ['todos'],
  queryFn: () => fetch('/api/todos').then((res) => res.json()),
  staleTime: 60000,
  gcTime: 300000,
})

// 内部执行过程 (简化)
class QueryObserver extends Subscribable {
  #client: QueryClient
  #currentQuery: Query
  #currentResult: QueryObserverResult
  #currentThenable: Thenable<TData> // 用于异步结果追踪
  #selectError: Error | null

  constructor(client, options) {
    super()
    this.#client = client
    this.#currentThenable = pendingThenable()
    this.#selectError = null

    // 绑定this指向
    this.bindMethods()
    // 设置初始选项并创建查询对象
    this.setOptions(options)
  }
}

// 订阅查询结果
const unsubscribe = observer.subscribe((result) => {
  const { status, data, error } = result
  // 处理查询结果...
})

// 内部执行过程 (简化)
class QueryObserver {
  // ... 构造函数等 (省略)

  protected onSubscribe(): void {
    // 首次有订阅者时才开始工作
    if (this.listeners.size === 1) {
      this.#currentQuery.addObserver(this)

      // 检查是否需要立即请求数据
      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
        this.#executeFetch()
      } else {
        // 即使不请求数据也要通知当前状态
        this.updateResult()
      }
    }
  }

  subscribe(listener): () => void {
    this.listeners.add(listener)
    this.onSubscribe()

    // 返回取消订阅函数
    return () => {
      this.listeners.delete(listener)
      this.onUnsubscribe()
    }
  }
}

// 执行获取的内部实现 (简化)
class QueryObserver {
  // ... 其他方法 (省略)

  #executeFetch(
    fetchOptions?: Omit<ObserverFetchOptions, 'initialPromise'>,
  ): Promise<TQueryData | undefined> {
    // 先更新查询实例引用，确保使用最新的 Query
    this.#updateQuery()
    // 调用查询实例的fetch方法
    let promise = this.#currentQuery.fetch(
      this.options as QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey>,
      fetchOptions,
    )
    // 捕获错误以防止Promise链中断
    if (!fetchOptions?.throwOnError) {
      promise = promise.catch(noop)
    }
    return promise
  }

  #updateQuery(): void {
    // 从缓存获取或创建查询实例
    const query = this.#client.getQueryCache().build(this.#client, this.options)
    if (query === this.#currentQuery) {
      return
    }
    const prevQuery = this.#currentQuery
    this.#currentQuery = query
    this.#currentQueryInitialState = query.state
    // 如果有监听器，更新观察者注册
    if (this.hasListeners()) {
      prevQuery?.removeObserver(this)
      query.addObserver(this)
    }
  }
}

// 查询缓存的构建方法 (简化)
class QueryCache extends Subscribable<QueryCacheListener> {
  #queries: QueryStore

  constructor(public config: QueryCacheConfig = {}) {
    super()
    this.#queries = new Map<string, Query>()
  }

  build(
    client: QueryClient,
    options: WithRequired<QueryOptions, 'queryKey'>,
    state?: QueryState,  // 可选的初始状态参数，用于 hydration 等场景
  ): Query {
    const queryKey = options.queryKey
    // 计算查询键的哈希值
    const queryHash =
      options.queryHash ?? hashQueryKeyByOptions(queryKey, options)
    // 检查缓存中是否已存在
    let query = this.get(queryHash)
    // 若不存在则创建新查询实例
    if (!query) {
      query = new Query({
        client,
        queryKey,
        queryHash,
        options: client.defaultQueryOptions(options),
        state,  // 传递可选的初始状态
        defaultOptions: client.getQueryDefaults(queryKey),
      })
      // 将新查询添加到缓存
      this.add(query)
    }
    return query
  }
}

// Query 实例的 fetch 方法被调用 (简化)
class Query extends Removable {
  #retryer?: Retryer<TData>
  #cache: QueryCache
  #client: QueryClient
  #revertState?: QueryState<TData, TError>
  #abortSignalConsumed: boolean
  state: QueryState<TData, TError>
  observers: Array<QueryObserver<any, any, any, any, any>>

  constructor(config: QueryConfig) {
    super()
    this.#abortSignalConsumed = false
    this.observers = []
    this.#client = config.client
    this.#cache = this.#client.getQueryCache()
    this.queryKey = config.queryKey
    this.queryHash = config.queryHash
    // ... 其他初始化 (省略)
  }

  async fetch(options, fetchOptions): Promise<TData> {
    // 检查是否已有请求在进行中
    if (
      this.state.fetchStatus !== 'idle' &&
      this.#retryer?.status() !== 'rejected'
    ) {
      if (this.state.data !== undefined && fetchOptions?.cancelRefetch) {
        this.cancel({ silent: true })
      } else if (this.#retryer) {
        this.#retryer.continueRetry()
        return this.#retryer.promise
      }
    }

    if (options) this.setOptions(options)

    const abortController = new AbortController()

    const fetchFn = () => {
      const queryFn = ensureQueryFn(this.options, fetchOptions)
      const queryFnContext = {
        client: this.#client,
        queryKey: this.queryKey,
        meta: this.meta,
      }
      // addSignalProperty(queryFnContext) - 访问 signal 时标记已消费
      return queryFn(queryFnContext)
    }

    const context = createFetchContext()
    this.options.behavior?.onFetch(context, this)
    this.#revertState = this.state

    if (
      this.state.fetchStatus === 'idle' ||
      this.state.fetchMeta !== context.fetchOptions?.meta
    ) {
      this.#dispatch({ type: 'fetch', meta: context.fetchOptions?.meta })
    }

    // 创建 Retryer - 回调用于中间状态处理，不是最终结果
    this.#retryer = createRetryer({
      initialPromise: fetchOptions?.initialPromise,
      fn: context.fetchFn as () => Promise<TData>,
      onCancel: (error) => {
        if (error instanceof CancelledError && error.revert) {
          this.setState({ ...this.#revertState, fetchStatus: 'idle' })
        }
        abortController.abort()
      },
      onFail: (failureCount, error) => {
        this.#dispatch({ type: 'failed', failureCount, error })
      },
      onPause: () => {
        this.#dispatch({ type: 'pause' })
      },
      onContinue: () => {
        this.#dispatch({ type: 'continue' })
      },
      retry: context.options.retry,
      retryDelay: context.options.retryDelay,
      networkMode: context.options.networkMode,
      canRun: () => true,
    })

    // 使用 try/catch 处理最终结果
    try {
      const data = await this.#retryer.start()

      if (data === undefined) {
        throw new Error(`${this.queryHash} data is undefined`)
      }

      this.setData(data)
      this.#cache.config.onSuccess?.(data, this)
      this.#cache.config.onSettled?.(data, this.state.error, this)

      return data
    } catch (error) {
      if (error instanceof CancelledError) {
        if (error.silent) return this.#retryer.promise
        if (error.revert && this.state.data !== undefined) return this.state.data
      }

      this.#dispatch({ type: 'error', error })
      this.#cache.config.onError?.(error, this)
      this.#cache.config.onSettled?.(this.state.data, error, this)

      throw error
    } finally {
      this.scheduleGc()
    }
  }
}

// Retryer 成功后调用 Query.setData (简化)
class Query {
  // ... 其他方法 (省略)

  setData(newData, options): TData {
    // 使用不可变数据更新
    const data = replaceData(this.state.data, newData, this.options)
    this.#dispatch({
      data,
      type: 'success',
      dataUpdatedAt: options?.updatedAt,
      manual: options?.manual,
    })
    return data
  }
}

// 数据传播到 Observer 并触发监听器 (简化)
class QueryObserver {
  // ... 其他方法 (省略)

  // 在查询状态更新时重新生成结果对象并通知
  updateResult(notifyOptions?: NotifyOptions): void {
    // ... 获取旧结果 (省略)
    // const prevResult = this.#currentResult

    // 根据最新查询状态创建新结果
    const nextResult = this.createResult(this.#currentQuery, this.options)

    // ... 更新内部状态引用 (省略)
    // this.#currentResultState = ...
    // this.#currentResultOptions = ...

    // ... 更新最近有数据的查询引用 (省略)

    // ... 检查结果是否有变化 (省略)
    // if (shallowEqualObjects(nextResult, prevResult)) { return }

    // 更新当前结果对象
    this.#currentResult = nextResult

    // ... 准备默认通知选项 (省略)

    // 判断是否需要通知监听器 (基于配置和变化)
    const shouldNotifyListeners = (): boolean => {
      // ... 复杂的判断逻辑 (省略)
      return true // 简化的返回值
    }

    // ... 根据判断结果设置通知选项 (省略)
    // if (notifyOptions?.listeners !== false && shouldNotifyListeners()) { ... }

    // 调用通知方法，触发所有监听器 (如果需要)
    this.#notify({
      /* ... 合并后的通知选项 ... */
    })
  }

  // 构建结果对象 (简化)
  protected createResult(query, options): QueryObserverResult {
    // 1. 获取之前的 Query, Options, Result 等用于比较和优化 (省略)
    // ...

    // 2. 获取当前查询状态，并根据 optimisticResults 配置进行潜在调整，得到基础状态 newState
    const { state } = query
    let newState = { ...state }
    let isPlaceholderData = false
    let data: TData | undefined

    if (options._optimisticResults) {
      // ... 乐观结果逻辑，修改 newState (省略)
    }

    // 3. 从调整后的 newState 中解构出部分基础状态
    let { error, errorUpdatedAt, status } = newState

    // 4. 处理数据: select 转换 / placeholder 数据 (此过程可能修改 data 等)
    if (options.select && newState.data !== undefined) {
      // ... select 数据转换逻辑，可能设置 data 和 #selectError (省略)
    } else {
      data = newState.data as unknown as TData
    }

    if (
      options.placeholderData !== undefined &&
      data === undefined &&
      status === 'pending'
    ) {
      // ... placeholder 数据处理逻辑
    }

    // 5. 处理 select 过程中可能发生的错误 (#selectError)
    if (this.#selectError) {
      // ...
    }

    // 6. 计算最终的派生状态标志 (isFetching 等)
    // ... 派生状态计算逻辑 (省略)

    // 7. 组装并返回最终结果对象
    return {
      status,
      fetchStatus: newState.fetchStatus,
      data,
      error,
      dataUpdatedAt: newState.dataUpdatedAt,
      errorUpdatedAt,
      // ... 各种派生状态标志 (省略)
      isStale: isStale(query, options),
      refetch: this.refetch,
      // ... 其他属性 (省略)
    }
  }
}