arcadia-admin/app/lib/arcadia/networking.ts

// Networking helpers: firewalls, VPCs, domains + DNS records, floating IPs.
// Backend: /api/v1/platform/{firewalls,vpcs,domains,floating_ips,...}.

import type { ArcadiaClient } from "@crema/arcadia-core-client"

const BASE = "/api/v1/platform"

// --- Firewalls ----------------------------------------------------------

export interface Firewall {
  id: string | number
  name: string
  status?: string
  inbound_rules?: unknown[]
  outbound_rules?: unknown[]
  droplet_ids?: Array<string | number>
  created_at?: string
  [key: string]: unknown
}

export async function listFirewalls(arcadia: ArcadiaClient): Promise<Firewall[]> {
  try {
    const res = await arcadia.GET<{ firewalls?: Firewall[]; data?: Firewall[] }>(
      `${BASE}/firewalls`,
    )
    return res.firewalls ?? res.data ?? []
  } catch {
    return []
  }
}

export async function createFirewall(
  arcadia: ArcadiaClient,
  input: Partial<Firewall>,
): Promise<unknown> {
  return arcadia.POST(`${BASE}/firewalls`, { body: input })
}

export async function deleteFirewall(
  arcadia: ArcadiaClient,
  id: string | number,
): Promise<void> {
  await arcadia.DELETE(`${BASE}/firewalls/${id}`)
}

// --- VPCs ---------------------------------------------------------------

export interface Vpc {
  id: string
  name: string
  region?: string
  ip_range?: string
  default?: boolean
  created_at?: string
  [key: string]: unknown
}

export async function listVpcs(arcadia: ArcadiaClient): Promise<Vpc[]> {
  try {
    const res = await arcadia.GET<{ vpcs?: Vpc[]; data?: Vpc[] }>(`${BASE}/vpcs`)
    return res.vpcs ?? res.data ?? []
  } catch {
    return []
  }
}

// --- Domains + DNS records ----------------------------------------------

export interface Domain {
  name: string
  ttl?: number
  zone_file?: string | null
  [key: string]: unknown
}

export interface DnsRecord {
  id: string | number
  type: string
  name: string
  data: string
  priority?: number | null
  port?: number | null
  ttl?: number
  weight?: number | null
  [key: string]: unknown
}

export async function listDomains(arcadia: ArcadiaClient): Promise<Domain[]> {
  try {
    const res = await arcadia.GET<{ domains?: Domain[]; data?: Domain[] }>(`${BASE}/domains`)
    return res.domains ?? res.data ?? []
  } catch {
    return []
  }
}

export async function listDnsRecords(
  arcadia: ArcadiaClient,
  domainName: string,
): Promise<DnsRecord[]> {
  const res = await arcadia.GET<{ domain_records?: DnsRecord[]; data?: DnsRecord[] }>(
    `${BASE}/domains/${encodeURIComponent(domainName)}/records`,
  )
  return res.domain_records ?? res.data ?? []
}

export async function createDnsRecord(
  arcadia: ArcadiaClient,
  domainName: string,
  input: { type: string; name: string; data: string; ttl?: number; priority?: number },
): Promise<unknown> {
  return arcadia.POST(`${BASE}/domains/${encodeURIComponent(domainName)}/records`, {
    body: input,
  })
}

export async function deleteDnsRecord(
  arcadia: ArcadiaClient,
  domainName: string,
  recordId: string | number,
): Promise<void> {
  await arcadia.DELETE(
    `${BASE}/domains/${encodeURIComponent(domainName)}/records/${recordId}`,
  )
}

// --- Floating IPs -------------------------------------------------------

export interface FloatingIp {
  ip: string
  region?: { slug?: string; name?: string } | string
  droplet?: { id: number | string; name?: string } | null
  [key: string]: unknown
}

export async function listFloatingIps(arcadia: ArcadiaClient): Promise<FloatingIp[]> {
  try {
    const res = await arcadia.GET<{ floating_ips?: FloatingIp[]; data?: FloatingIp[] }>(
      `${BASE}/floating_ips`,
    )
    return res.floating_ips ?? res.data ?? []
  } catch {
    return []
  }
}

export async function assignFloatingIp(
  arcadia: ArcadiaClient,
  ip: string,
  dropletId: number | string,
): Promise<unknown> {
  return arcadia.POST(`${BASE}/floating_ips/${ip}/assign`, {
    body: { droplet_id: dropletId },
  })
}

export async function unassignFloatingIp(
  arcadia: ArcadiaClient,
  ip: string,
): Promise<unknown> {
  return arcadia.POST(`${BASE}/floating_ips/${ip}/unassign`)
}