import { render, type RenderResult } from '@testing-library/svelte'
import { tick } from 'svelte'
import type { ComponentType } from 'svelte'

export async function renderAndWait<T extends ComponentType>(
  component: T,
  options?: Parameters<typeof render>[1]
): Promise<RenderResult<T>> {
  const result = render(component, options)
  await tick()
  await new Promise(resolve => setTimeout(resolve, 0))
  return result
}

export async function waitForElement(
  queryFn: () => HTMLElement | null,
  timeout = 1000
): Promise<HTMLElement> {
  const start = Date.now()
  while (Date.now() - start < timeout) {
    const element = queryFn()
    if (element) return element
    await new Promise(resolve => setTimeout(resolve, 10))
  }
  throw new Error('Element not found within timeout')
}

export async function waitForElementToDisappear(
  queryFn: () => HTMLElement | null,
  timeout = 1000
): Promise<void> {
  const start = Date.now()
  while (Date.now() - start < timeout) {
    const element = queryFn()
    if (!element) return
    await new Promise(resolve => setTimeout(resolve, 10))
  }
  throw new Error('Element still present after timeout')
}

export async function waitForText(
  container: HTMLElement,
  text: string | RegExp,
  timeout = 1000
): Promise<void> {
  const start = Date.now()
  while (Date.now() - start < timeout) {
    const content = container.textContent || ''
    if (typeof text === 'string' ? content.includes(text) : text.test(content)) {
      return
    }
    await new Promise(resolve => setTimeout(resolve, 10))
  }
  throw new Error(`Text "${text}" not found within timeout`)
}

export function mockLocalStorage(initialData: Record<string, string> = {}): void {
  const store: Record<string, string> = { ...initialData }
  Object.defineProperty(window, 'localStorage', {
    value: {
      getItem: (key: string) => store[key] || null,
      setItem: (key: string, value: string) => { store[key] = value },
      removeItem: (key: string) => { delete store[key] },
      clear: () => { Object.keys(store).forEach(key => delete store[key]) },
      key: (index: number) => Object.keys(store)[index] || null,
      get length() { return Object.keys(store).length },
    },
    writable: true,
  })
}

export function setAuthState(session: {
  did: string
  handle: string
  email?: string
  emailConfirmed?: boolean
  accessJwt: string
  refreshJwt: string
}): void {
  localStorage.setItem('session', JSON.stringify(session))
}

export function clearAuthState(): void {
  localStorage.removeItem('session')
}