Blame for src/lib/apiAdapter.ts

import { supabase } from './supabase'

// --- Strangler Pattern Configuration Switches ---

const USE_GO_GATEWAY: Record<string, boolean> = {
  'verify-receipt': false,
  'nature-letter': false,
  'embed-text': false,
  'explain-methodology': false,
  'mock-vcs': false,
}

let GO_GATEWAY_URL = 'http://localhost:8080'

const GO_GATEWAY_ENDPOINTS: Record<string, (payload: unknown) => string> = {
  'verify-receipt': (payload) => {
    const submissionId = getPayloadString(payload, 'submissionId') ?? getPayloadString(payload, 'id')
    return submissionId ? `/submissions/${encodeURIComponent(submissionId)}/verify` : '/verify-receipt'
  },
  'nature-letter': () => '/nature/letter',
  'embed-text': () => '/methodologies/reseed',
  'explain-methodology': () => '/methodologies/match',
  'mock-vcs': () => '/registries/vcs/submit',
}

export function setUseGoGateway(functionName: string, use: boolean): void {
  if (functionName in USE_GO_GATEWAY) {
    USE_GO_GATEWAY[functionName] = use
  }
}

export function setGoGatewayUrl(url: string): void {
  GO_GATEWAY_URL = url
}

function getPayloadString(payload: unknown, key: string): string | undefined {
  if (!payload || typeof payload !== 'object') return undefined
  const value = (payload as Record<string, unknown>)[key]
  return typeof value === 'string' && value.trim().length > 0 ? value : undefined
}

function isEnvelopeResponse(value: unknown): value is { data: unknown; error?: unknown } {
  return (
    !!value &&
    typeof value === 'object' &&
    'data' in value &&
    'meta' in value &&
    'error' in value
  )
}

function unwrapEnvelope(functionName: string, response: unknown): unknown {
  if (!isEnvelopeResponse(response)) return response
  if (response.error) {
    throw new Error(`[apiAdapter] ${functionName} Gateway 응답 오류: ${String(response.error)}`)
  }
  return response.data
}

// --- Data Contract Verification Guard (Contract Assertions) ---

/**
 * Go Gateway로 이주하거나 Deno 함수 통신 시 데이터 스키마 깨짐(Contract Broken)으로 인한
 * 프론트엔드 폭사를 막는 런타임 타입 검증 가드
 */
function assertDataContract(functionName: string, data: unknown): void {
  if (!data) {
    throw new Error(`[apiAdapter] API 계약 검증 실패: ${functionName} 응답이 비어있습니다.`)
  }

  const record = data as Record<string, unknown>

  switch (functionName) {
    case 'verify-receipt':
      if (record.success === undefined && record.status === undefined) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: verify-receipt 응답에 필수 필드(success)가 누락되었습니다.`)
      }
      if (record.co2Reduction === undefined && record.co2_reduction === undefined) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: verify-receipt 응답에 필수 필드(co2Reduction)가 누락되었습니다.`)
      }
      break;

    case 'nature-letter':
      if (!record.body) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: nature-letter 응답에 필수 필드(body)가 누락되었습니다.`)
      }
      break;

    case 'embed-text':
      if (!Array.isArray(record.embedding)) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: embed-text 응답에 필수 필드(embedding)가 누락되었습니다.`)
      }
      break;

    case 'explain-methodology':
      if (record.eligibilityScore === undefined && record.eligibility_score === undefined) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: explain-methodology 응답에 필수 필드(eligibilityScore)가 누락되었습니다.`)
      }
      if (!record.explanation) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: explain-methodology 응답에 필수 필드(explanation)가 누락되었습니다.`)
      }
      break;

    case 'mock-vcs':
      if (record.success === undefined) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: mock-vcs 응답에 필수 필드(success)가 누락되었습니다.`)
      }
      if (!record.externalId && !record.external_id) {
        throw new Error(`[apiAdapter] API 계약 검증 실패: mock-vcs 응답에 필수 필드(externalId)가 누락되었습니다.`)
      }
      break;

    default:
      // Unrecognized function, bypass contract validation
      break;
  }
}

// --- Unified API Adapter Caller ---

/**
 * 5대 Supabase Deno Edge Functions 호출을 단일 추상화하여 호출하고
 * Go API 게이트웨이 완공 시 라우팅을 점진적으로 안전 우회(Strangler Pattern)시킵니다.
 */
export async function invokeEdgeFunction<TReq, TRes>(
  functionName: string,
  payload: TReq
): Promise<TRes> {
  const useGo = USE_GO_GATEWAY[functionName] || false

  if (useGo) {
    // 1. Go API Gateway로 우회 (fetch API)
    const endpoint = GO_GATEWAY_ENDPOINTS[functionName]?.(payload) ?? `/${functionName}`
    const targetUrl = `${GO_GATEWAY_URL}/api/v1${endpoint}`
    const response = await fetch(targetUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(payload),
    })

    if (!response.ok) {
      const errText = await response.text()
      throw new Error(`[apiAdapter] Go Gateway API 호출 실패 (${response.status}): ${errText}`)
    }

    const rawData = await response.json()
    const resData = unwrapEnvelope(functionName, rawData)

    // 런타임 데이터 계약 검증
    assertDataContract(functionName, resData)
    return resData as TRes
  } else {
    // 2. 기존 Supabase Deno Edge Function 호출
    const { data, error } = await supabase.functions.invoke(functionName, {
      body: payload as Record<string, unknown>,
    })

    if (error) {
      throw new Error(error.message || String(error))
    }

    // 런타임 데이터 계약 검증
    const resData = unwrapEnvelope(functionName, data)
    assertDataContract(functionName, resData)
    return resData as TRes
  }
}