// Строим упрощённый аналог TanStack Query на чистом JavaScript.
// Понимание внутренней работы помогает правильно использовать библиотеку.

// --- QueryCache ---

class QueryCache {
  constructor() {
    this.cache = new Map()     // queryKey -> CacheEntry
    this.observers = new Map() // queryKey -> Set<callback>
  }

  // Формируем строковый ключ из массива
  getKey(queryKey) {
    return JSON.stringify(queryKey)
  }

  get(queryKey) {
    return this.cache.get(this.getKey(queryKey))
  }

  set(queryKey, entry) {
    const key = this.getKey(queryKey)
    this.cache.set(key, entry)
    this.notify(key)
  }

  invalidate(queryKey) {
    const key = this.getKey(queryKey)
    const entry = this.cache.get(key)
    if (entry) {
      entry.isStale = true
      this.notify(key)
    }
  }

  subscribe(queryKey, callback) {
    const key = this.getKey(queryKey)
    if (!this.observers.has(key)) this.observers.set(key, new Set())
    this.observers.get(key).add(callback)
    return () => this.observers.get(key)?.delete(callback)
  }

  notify(key) {
    this.observers.get(key)?.forEach(fn => fn())
  }
}

// --- QueryClient ---

class QueryClient {
  constructor() {
    this.cache = new QueryCache()
    this.inFlight = new Map()  // queryKey -> Promise (дедупликация!)
  }

  async fetchQuery({ queryKey, queryFn, staleTime = 0 }) {
    const key = JSON.stringify(queryKey)
    const cached = this.cache.get(queryKey)

    // 1. Данные свежие — возвращаем из кэша без запроса
    if (cached && !cached.isStale) {
      const age = Date.now() - cached.fetchedAt
      if (age < staleTime) {
        console.log('Cache HIT [fresh]:', key, '(возраст: ' + age + 'мс)')
        return cached.data
      }
    }

    // 2. Запрос уже выполняется — дедупликация, ждём тот же промис
    if (this.inFlight.has(key)) {
      console.log('Dedup [in-flight]:', key, '— ожидаем существующий запрос')
      return this.inFlight.get(key)
    }

    // 3. Новый запрос
    console.log('Cache MISS:', key, '— отправляем запрос...')

    const promise = queryFn()
      .then(data => {
        this.cache.set(queryKey, {
          data,
          fetchedAt: Date.now(),
          isStale: false,
          error: null,
        })
        this.inFlight.delete(key)
        return data
      })
      .catch(error => {
        this.cache.set(queryKey, {
          data: null,
          fetchedAt: Date.now(),
          isStale: true,
          error: error.message,
        })
        this.inFlight.delete(key)
        throw error
      })

    this.inFlight.set(key, promise)
    return promise
  }

  setQueryData(queryKey, updater) {
    const cached = this.cache.get(queryKey)
    const currentData = cached?.data || null
    const newData = typeof updater === 'function' ? updater(currentData) : updater

    this.cache.set(queryKey, {
      data: newData,
      fetchedAt: Date.now(),
      isStale: false,
      error: null,
    })
  }

  invalidateQueries(queryKey) {
    this.cache.invalidate(queryKey)
    console.log('Invalidated:', JSON.stringify(queryKey))
  }

  getQueryData(queryKey) {
    return this.cache.get(queryKey)?.data || null
  }
}

// --- Fake API ---

let requestCount = 0
const fakeDB = {
  users: {
    1: { id: 1, name: 'Алексей', email: 'alex@example.com' },
    2: { id: 2, name: 'Мария', email: 'maria@example.com' },
  }
}

function fetchUser(id) {
  requestCount++
  const reqNum = requestCount
  console.log('  [API] Запрос #' + reqNum + ' для userId=' + id)
  return new Promise(resolve =>
    setTimeout(() => {
      console.log('  [API] Ответ #' + reqNum)
      resolve(fakeDB.users[id])
    }, 50)
  )
}

// --- Тесты ---

async function runTests() {
  const client = new QueryClient()

  console.log('=== Тест 1: Базовый fetch и кэш ===')
  const user1a = await client.fetchQuery({
    queryKey: ['user', 1],
    queryFn: () => fetchUser(1),
    staleTime: 5000,
  })
  console.log('Результат:', user1a.name)

  // Повторный запрос — должен вернуть из кэша
  const user1b = await client.fetchQuery({
    queryKey: ['user', 1],
    queryFn: () => fetchUser(1),
    staleTime: 5000,
  })
  console.log('Из кэша:', user1b.name)
  console.log('HTTP запросов всего:', requestCount, '(должно быть 1)')

  console.log('
=== Тест 2: Дедупликация ===')
  requestCount = 0

  // Параллельные запросы к одному ресурсу
  const [u1, u2, u3] = await Promise.all([
    client.fetchQuery({ queryKey: ['user', 2], queryFn: () => fetchUser(2) }),
    client.fetchQuery({ queryKey: ['user', 2], queryFn: () => fetchUser(2) }),
    client.fetchQuery({ queryKey: ['user', 2], queryFn: () => fetchUser(2) }),
  ])
  console.log('3 параллельных запроса, HTTP запросов:', requestCount, '(должно быть 1)')
  console.log('Все результаты одинаковые:', u1.name === u2.name && u2.name === u3.name)

  console.log('
=== Тест 3: Оптимистичное обновление ===')
  const userId = 1

  // Сохраняем старые данные
  const old = client.getQueryData(['user', userId])
  console.log('До обновления:', old?.name)

  // Оптимистично меняем кэш (до ответа сервера)
  client.setQueryData(['user', userId], old => ({ ...old, name: 'Алексей Обновлённый' }))
  console.log('Оптимистично:', client.getQueryData(['user', userId])?.name)

  console.log('
=== Тест 4: Инвалидация ===')
  client.invalidateQueries(['user', 1])
  const afterInvalidate = client.cache.get(['user', 1])
  console.log('После инвалидации isStale:', afterInvalidate?.isStale)  // true
}

runTests()