import yaml from 'js-yaml'
import type { FolderConfig, CollectionRequestDefaults, HeaderItem, AuthConfig, VarItem } from '../types.js'

function parseHeaders(raw: unknown): HeaderItem[] {
  if (!Array.isArray(raw)) return []
  return raw.map((h: Record<string, unknown>) => ({
    name: String(h.name ?? ''),
    value: String(h.value ?? ''),
    disabled: Boolean(h.disabled),
  }))
}

function parseVars(raw: unknown): VarItem[] {
  if (!Array.isArray(raw)) return []
  return raw.map((v: Record<string, unknown>) => ({
    name: String(v.name ?? ''),
    value: String(v.value ?? ''),
    enabled: v.enabled !== false,
    local: Boolean(v.local),
  }))
}

function parseAuth(raw: unknown): AuthConfig | undefined {
  if (!raw || typeof raw !== 'object') return undefined
  const r = raw as Record<string, unknown>
  const type = String(r.type ?? 'none')
  const auth: AuthConfig = { type }

  if (type === 'basic' && r.basic && typeof r.basic === 'object') {
    const b = r.basic as Record<string, unknown>
    auth.basic = { username: String(b.username ?? ''), password: String(b.password ?? '') }
  }
  if (type === 'bearer' && r.bearer && typeof r.bearer === 'object') {
    const b = r.bearer as Record<string, unknown>
    auth.bearer = { token: String(b.token ?? '') }
  }

  return auth
}

function parseRequestDefaults(raw: unknown): CollectionRequestDefaults | undefined {
  if (!raw || typeof raw !== 'object') return undefined
  const r = raw as Record<string, unknown>

  const scriptRaw = r.script as Record<string, unknown> | undefined
  const varsRaw = r.vars as Record<string, unknown> | undefined

  return {
    auth: parseAuth(r.auth),
    headers: parseHeaders(r.headers),
    script: scriptRaw
      ? {
          req: typeof scriptRaw.req === 'string' ? scriptRaw.req : undefined,
          res: typeof scriptRaw.res === 'string' ? scriptRaw.res : undefined,
        }
      : undefined,
    tests: typeof r.tests === 'string' ? r.tests : undefined,
    vars: varsRaw
      ? { req: parseVars(varsRaw.req), res: parseVars(varsRaw.res) }
      : undefined,
  }
}

export function parseFolder(yamlContent: string): FolderConfig {
  const raw = yaml.load(yamlContent) as Record<string, unknown>

  if (!raw || typeof raw !== 'object') {
    throw new Error('Invalid folder.yml — expected an object')
  }

  const metaRaw = raw.meta as Record<string, unknown> | undefined
  const name = typeof metaRaw?.name === 'string' ? metaRaw.name : 'folder'
  const seq = typeof metaRaw?.seq === 'number' ? metaRaw.seq : undefined

  return {
    meta: { name, seq },
    request: parseRequestDefaults(raw.request),
  }
}