import type {
  SplitEntry,
  TransformContext,
  ValidationWarning,
  ZodValidationMode,
} from '../../types'
import { validateStage } from './validate'

export interface SplitResult {
  data: unknown
  warnings: ValidationWarning[]
}

export async function splitStage(
  ctx: TransformContext,
  split: Record<string, SplitEntry>,
  zodMode: ZodValidationMode = 'warn',
): Promise<Record<string, SplitResult>> {
  const results: Record<string, SplitResult> = {}

  for (const [outputKey, entry] of Object.entries(split)) {
    const extracted = extractEntry(outputKey, ctx.data, entry)
    // Auto-BFF mode (no explicit path or transform): skip sections absent from
    // the response so that a partial API reply doesn't wipe unrelated slices.
    if (extracted === undefined && !entry.path && !entry.transform) continue
    const responseCtx = { key: outputKey, response: extracted, duration: 0 }
    const validated = await validateStage(responseCtx, entry.schema, zodMode)
    results[outputKey] = { data: validated.data, warnings: validated.warnings }
  }

  return results
}

function extractEntry(
  outputKey: string,
  data: unknown,
  entry: SplitEntry,
): unknown {
  if (entry.transform) {
    try {
      return entry.transform(data)
    } catch {
      return null
    }
  }
  return getByPath(data, entry.path ?? outputKey)
}

function getByPath(obj: unknown, path: string): unknown {
  return path.split('.').reduce((cur: unknown, key) => {
    if (cur == null || typeof cur !== 'object') return undefined
    return (cur as Record<string, unknown>)[key]
  }, obj)
}