import { WeaverseClient } from '@weaverse/hydrogen'

export async function createAppLoadContext(
  request: Request,
  env: Env,
  executionContext: ExecutionContext
) {
  const hydrogenContext = createHydrogenContext({
    env,
    request,
    cache,
    waitUntil,
    session,
    i18n: getLocaleFromRequest(request),
    cart: { queryFragment: CART_QUERY_FRAGMENT },
  })

  return {
    ...hydrogenContext,
    weaverse: new WeaverseClient({
      ...hydrogenContext,
      request,
      cache,
      themeSchema,
      components,
      // Optional: override env-based project resolution
      projectId: env.WEAVERSE_PROJECT_ID,
      // Optional: request timeout in milliseconds
      fetchTimeoutMs: 10_000,
    }),
  }
}

class WeaverseClient {
  constructor(args: WeaverseClientArgs)

  API: 'v1'
  basePageConfigs: Omit<WeaverseProjectConfigs, 'requestInfo'>
  basePageRequestBody: Omit<FetchProjectRequestBody, 'url'>
  configs: WeaverseProjectConfigs
  storefront: WeaverseClientArgs['storefront']
  customerAccount: WeaverseClientArgs['customerAccount']
  env: WeaverseClientArgs['env']
  cache: WeaverseClientArgs['cache']
  waitUntil: WeaverseClientArgs['waitUntil']
  request: WeaverseClientArgs['request']
  components: WeaverseClientArgs['components']
  themeSchema: WeaverseClientArgs['themeSchema']
  withCache: ReturnType<typeof createWithCache>

  fetchWithCache<T>(
    url: string,
    options?: WeaverseFetchWithCacheOptions
  ): Promise<T>
  fetchCustomPages(options?: FetchCustomPagesOptions): Promise<CustomPageEntry[]>
  loadThemeSettings(strategy?: CachingStrategy): Promise<ThemeSettingsResponse>
  loadPage(params?: LoadPageParams): Promise<WeaverseLoaderData | null>
  execComponentLoader(item: HydrogenComponentData): Promise<HydrogenComponentData>
  generateFallbackPage(message: string): HydrogenPageData
}

type WeaverseClientArgs = HydrogenContext & {
  components: HydrogenComponent[]
  themeSchema: HydrogenThemeSchema
  request: Request
  cache: Cache
  projectId?: string | (() => string) | (() => Promise<string>)
  fetchTimeoutMs?: number
}

fetchWithCache<T>(
  url: string,
  options?: RequestInit & {
    cacheTarget?: BuilderApiCacheTarget
    strategy?: CachingStrategy
  }
): Promise<T>

export async function loader({ weaverse }: ComponentLoaderArgs) {
  const products = await weaverse.fetchWithCache<Product[]>(
    'https://api.example.com/products',
    {
      strategy: {
        maxAge: 60,
        staleWhileRevalidate: 600,
      },
    }
  )

  return { products }
}

loadThemeSettings(
  strategy?: CachingStrategy
): Promise<ThemeSettingsResponse>

type ThemeSettingsResponse = {
  theme?: HydrogenThemeSettings
  schema?: HydrogenThemeSchema
  publicEnv?: PublicEnv
  staticContent?: Record<string, unknown>
  merchantOverrides?: Record<string, unknown>
  _error?: string
  _loadFailed?: boolean
}

export async function loader({ context }: Route.LoaderArgs) {
  return {
    weaverseTheme: await context.weaverse.loadThemeSettings(),
  }
}

loadPage(params?: {
  type?: PageType
  locale?: string
  handle?: string
  strategy?: CachingStrategy
  projectId?: string
}): Promise<WeaverseLoaderData | null>

strategy: {
  mode: 'public',
  maxAge: 3600,
  staleWhileRevalidate: 86400,
  sMaxAge: 7200,
  staleIfError: 604800,
}

export async function loader({ context, params }: Route.LoaderArgs) {
  const weaverseData = await context.weaverse.loadPage({
    type: 'PRODUCT',
    handle: params.productHandle,
    locale: 'en-US',
  })

  if (!weaverseData) {
    throw new Response('Weaverse page load failed', { status: 500 })
  }

  return { weaverseData }
}

fetchCustomPages(options?: {
  limit?: number
  locale?: string
}): Promise<CustomPageEntry[]>

const pages = await context.weaverse.fetchCustomPages({
  locale: 'en-US',
  limit: 100,
})

execComponentLoader(
  item: HydrogenComponentData
): Promise<HydrogenComponentData>

generateFallbackPage(message: string): HydrogenPageData