// Реализуем тест-хелперы для асинхронного тестирования без тестового фреймворка.

// --- waitFor: ждём выполнения условия ---

async function waitFor(assertion, options = {}) {
  const { timeout = 1000, interval = 50 } = options
  const startTime = Date.now()

  while (true) {
    try {
      assertion()  // бросает если условие не выполнено
      return true  // успех
    } catch (error) {
      if (Date.now() - startTime >= timeout) {
        throw new Error(
          'waitFor timeout после ' + timeout + 'мс: ' + error.message
        )
      }
      // Ждём следующей проверки
      await new Promise(resolve => setTimeout(resolve, interval))
    }
  }
}

// --- Mock Fetch ---

function createMockFetch(handlers) {
  const callLog = []

  const mockFetch = async (url, options = {}) => {
    const method = (options.method || 'GET').toUpperCase()
    callLog.push({ url, method, timestamp: Date.now() })

    // Ищем подходящий handler
    const handler = handlers.find(h => {
      const methodMatch = !h.method || h.method === method
      const urlMatch = typeof h.url === 'string'
        ? url.includes(h.url)
        : h.url.test(url)
      return methodMatch && urlMatch
    })

    if (!handler) {
      return { ok: false, status: 404, json: async () => ({ error: 'Not Found' }) }
    }

    // Симулируем задержку сети
    if (handler.delay) {
      await new Promise(r => setTimeout(r, handler.delay))
    }

    if (handler.status >= 400) {
      return { ok: false, status: handler.status, json: async () => handler.body }
    }

    return { ok: true, status: 200, json: async () => handler.body }
  }

  mockFetch.getCalls = () => [...callLog]
  mockFetch.getCallCount = () => callLog.length
  mockFetch.wasCalledWith = (url) => callLog.some(c => c.url.includes(url))

  return mockFetch
}

// --- Симуляция компонента с fetch ---

function createAsyncComponent(fetchFn) {
  let state = { status: 'idle', data: null, error: null }
  const listeners = []

  function setState(updates) {
    state = { ...state, ...updates }
    listeners.forEach(fn => fn(state))
  }

  async function load(id) {
    setState({ status: 'loading', error: null })

    try {
      const res = await fetchFn('/api/users/' + id)
      if (!res.ok) throw new Error('HTTP ' + res.status)
      const data = await res.json()
      setState({ status: 'success', data })
    } catch (error) {
      setState({ status: 'error', error: error.message, data: null })
    }
  }

  return {
    load,
    getState: () => ({ ...state }),
    subscribe: (fn) => listeners.push(fn),
  }
}

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

async function runTests() {
  console.log('=== Тест 1: waitFor базовое использование ===')

  let value = 0
  setTimeout(() => { value = 42 }, 100)

  await waitFor(() => {
    if (value !== 42) throw new Error('Ожидаем 42, получили ' + value)
  })
  console.log('waitFor: value достиг 42 ✓')

  // --- Тест 2: waitFor timeout ---

  console.log('
=== Тест 2: waitFor timeout ===')
  try {
    await waitFor(
      () => { throw new Error('никогда не выполнится') },
      { timeout: 100, interval: 20 }
    )
  } catch (err) {
    console.log('Timeout поймали:', err.message.includes('timeout') ? '✓' : '✗')
  }

  // --- Тест 3: Успешная загрузка ---

  console.log('
=== Тест 3: Успешная загрузка ===')

  const mockFetch = createMockFetch([
    { url: '/api/users', method: 'GET', delay: 50, status: 200,
      body: { id: 1, name: 'Алексей', role: 'Разработчик' } }
  ])

  const component = createAsyncComponent(mockFetch)
  const stateHistory = []
  component.subscribe(s => stateHistory.push(s.status))

  component.load(1)

  // Сразу должно быть loading
  await waitFor(() => {
    if (component.getState().status !== 'loading')
      throw new Error('Ожидаем loading')
  })
  console.log('Loading state: ✓')

  // Ждём success
  await waitFor(() => {
    if (component.getState().status !== 'success')
      throw new Error('Ожидаем success')
  })

  const state = component.getState()
  console.log('Success state: ✓')
  console.log('Данные:', state.data.name)  // Алексей

  // --- Тест 4: Ошибка ---

  console.log('
=== Тест 4: Обработка ошибки 404 ===')

  const errorFetch = createMockFetch([
    { url: '/api/users', method: 'GET', delay: 20, status: 404, body: { error: 'Not Found' } }
  ])

  const component2 = createAsyncComponent(errorFetch)
  component2.load(999)

  await waitFor(() => {
    if (component2.getState().status !== 'error')
      throw new Error('Ожидаем error')
  })

  console.log('Error state: ✓')
  console.log('Сообщение ошибки:', component2.getState().error)  // 'HTTP 404'

  // --- Тест 5: Mock Fetch логирование ---

  console.log('
=== Тест 5: Mock Fetch лог вызовов ===')
  console.log('Вызовов к errorFetch:', errorFetch.getCallCount())  // 1
  console.log('Был вызван с /api/users:', errorFetch.wasCalledWith('/api/users'))
  console.log('История вызовов:', errorFetch.getCalls().map(c => c.method + ' ' + c.url))
}

runTests()