/**
 * API client for the at-run VOD bundle
 */

const RUNNER_URL = import.meta.env.VITE_RUNNER_URL || "http://code-atrun-vyl7lg-cc8112-157-173-113-6.traefik.me"
const BUNDLE_PATH = import.meta.env.VITE_BUNDLE_PATH || "bundle/did:plc:p3cygo5s7wru2argeci6wfv6/atmosphereconf-vod/latest"

export interface Video {
  uri: string
  title: string
  creator: string
  duration: number
  createdAt: string
}

export interface StreamInfo {
  quality: string
  width: number
  height: number
  bandwidth: number
  codecs: string
  frameRate?: number
}

export interface VideoStreamsResult {
  uri: string
  streams: StreamInfo[]
  audioTracks: Array<{ name: string; default: boolean }>
}

export interface VideoMetadata {
  thumbnail: string // base64 encoded JPEG (single frame)
  spriteSheet: string // base64 encoded JPEG (sprite grid for preview)
  vtt: string // base64 encoded WebVTT
}

export interface Profile {
  did: string
  handle: string
  displayName?: string
  avatar?: string
  description?: string
}

async function callEndpoint<T>(endpoint: string, args: unknown = {}): Promise<T> {
  const url = `${RUNNER_URL}/${BUNDLE_PATH}/${endpoint}`
  const res = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(args),
  })

  if (!res.ok) {
    const error = await res.json().catch(() => ({ error: res.statusText }))
    throw new Error(error.error || "Request failed")
  }

  return res.json()
}

export async function listVideos(
  limit?: number,
  cursor?: string
): Promise<{ videos: Video[]; cursor?: string }> {
  return callEndpoint("listVideos", { limit, cursor })
}

export async function getVideo(uri: string): Promise<Video> {
  return callEndpoint("getVideo", { uri })
}

export async function getVideoStreams(uri: string): Promise<VideoStreamsResult> {
  return callEndpoint("getVideoStreams", { uri })
}

interface TaskResponse<T> {
  status: "pending" | "running" | "complete" | "error"
  taskId: string
  result?: T
  error?: string
  cachedAt?: string
}

/**
 * Call a task endpoint with automatic retry until complete
 */
async function callTask<T>(endpoint: string, args: unknown, maxRetries = 60, retryDelay = 2000): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    const response = await callEndpoint<TaskResponse<T>>(endpoint, args)

    if (response.status === "complete") {
      return response.result as T
    }

    if (response.status === "error") {
      throw new Error(response.error || "Task failed")
    }

    // pending or running - wait and retry
    await new Promise(resolve => setTimeout(resolve, retryDelay))
  }

  throw new Error("Task timeout - max retries exceeded")
}

export async function getVideoMetadata(uri: string): Promise<VideoMetadata> {
  return callTask("videoMetadata", { uri })
}

export async function getProfile(did: string): Promise<Profile> {
  return callEndpoint("getProfile", { did })
}

export function getPlaylistUrl(uri: string, quality?: string): string {
  const args: Record<string, string> = { uri }
  if (quality) args.quality = quality
  const queryString = new URLSearchParams(args).toString()
  return `${RUNNER_URL}/${BUNDLE_PATH}/getPlaylist?${queryString}`
}

/**
 * Format duration from nanoseconds to human readable
 */
export function formatDuration(nanoseconds: number): string {
  const totalSeconds = Math.floor(nanoseconds / 1_000_000_000)
  const hours = Math.floor(totalSeconds / 3600)
  const minutes = Math.floor((totalSeconds % 3600) / 60)
  const seconds = totalSeconds % 60

  if (hours > 0) {
    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`
  }
  return `${minutes}:${seconds.toString().padStart(2, "0")}`
}