export interface WizardForm {
  title: string
  stage: string
  assetType: string
  offerType: string
  commodities: string[]
  primaryCommodity: string
  country: string
  region: string
  city: string
  lat: string
  lng: string
  surfaceHa: string
  concessionCount: string
  dealTypes: string[]
  priceUsd: string
  headline: string
  sellReason: string
  sellerCompany: string
  sellerWebsite: string
  sellerType: string
  mineralizationType: string
  works: string[]
  waterAccess: string
  energyAccess: string
  esgEnvStatus: string
  esgClosurePlan: string
  esgCommunity: string
  esgLiabilities: string
  description: string
  contactName: string
  contactRole: string
  contactEmail: string
  contactPhone: string
  contactPreference: string
  hasAgent: boolean
}

type ListingRecord = {
  title: string; stage: string | null; assetType: string | null; offerType: string | null
  country: string; region: string | null; city: string | null; lat: number | null; lng: number | null
  surfaceHa: number | null; concessionCount: number | null; priceUsd: number | null
  headline: string | null; sellReason: string | null; sellerCompany: string | null
  sellerWebsite: string | null; sellerType: string | null; mineralizationType: string | null
  works: string | null; waterAccess: string | null; energyAccess: string | null
  esgEnvStatus: string | null; esgClosurePlan: string | null; esgCommunity: string | null
  esgLiabilities: string | null; description: string; contactName: string | null
  contactRole: string | null; contactEmail: string | null; contactPhone: string | null
  contactPreference: string | null; hasAgent: boolean
  commodities: { commodity: string; isPrimary: boolean }[]
  dealTypes: { dealType: string }[]
}

const s = (v: string | null | undefined) => v ?? ''
const n = (v: number | null | undefined) => (v == null ? '' : String(v))

/** Convierte una publicación existente en el formulario del asistente (para editar). */
export function listingToForm(l: ListingRecord): WizardForm {
  return {
    title: s(l.title),
    stage: s(l.stage),
    assetType: s(l.assetType),
    offerType: s(l.offerType),
    commodities: l.commodities.map((c) => c.commodity),
    primaryCommodity: l.commodities.find((c) => c.isPrimary)?.commodity ?? l.commodities[0]?.commodity ?? '',
    country: s(l.country) || 'CL',
    region: s(l.region),
    city: s(l.city),
    lat: n(l.lat),
    lng: n(l.lng),
    surfaceHa: n(l.surfaceHa),
    concessionCount: n(l.concessionCount),
    dealTypes: l.dealTypes.map((d) => d.dealType),
    priceUsd: n(l.priceUsd),
    headline: s(l.headline),
    sellReason: s(l.sellReason),
    sellerCompany: s(l.sellerCompany),
    sellerWebsite: s(l.sellerWebsite),
    sellerType: s(l.sellerType),
    mineralizationType: s(l.mineralizationType),
    works: l.works ? l.works.split(',').map((w) => w.trim()).filter(Boolean) : [],
    waterAccess: s(l.waterAccess),
    energyAccess: s(l.energyAccess),
    esgEnvStatus: s(l.esgEnvStatus),
    esgClosurePlan: s(l.esgClosurePlan),
    esgCommunity: s(l.esgCommunity),
    esgLiabilities: s(l.esgLiabilities),
    description: s(l.description),
    contactName: s(l.contactName),
    contactRole: s(l.contactRole),
    contactEmail: s(l.contactEmail),
    contactPhone: s(l.contactPhone),
    contactPreference: s(l.contactPreference),
    hasAgent: l.hasAgent,
  }
}

export function slugify(text: string): string {
  return text
    .toLowerCase()
    .normalize('NFD')
    .replace(/[\u0300-\u036f]/g, '')
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .slice(0, 80)
}

function numOrNull(s: string): number | null {
  if (!s || !s.trim()) return null
  const n = Number(s)
  return Number.isFinite(n) ? n : null
}

function toData(form: WizardForm) {
  const commodities = form.commodities.map((c) => ({
    commodity: c,
    isPrimary: c === form.primaryCommodity,
  }))
  return {
    slug: slugify(form.title),
    title: form.title.trim(),
    description: form.description.trim() || form.title.trim(),
    category: 'ACTIVO',
    assetType: form.assetType || null,
    stage: form.stage || null,
    country: form.country.trim(),
    region: form.region.trim() || null,
    city: form.city.trim() || null,
    lat: numOrNull(form.lat),
    lng: numOrNull(form.lng),
    priceUsd: numOrNull(form.priceUsd),
    surfaceHa: numOrNull(form.surfaceHa),
    concessionCount: numOrNull(form.concessionCount),
    imageSeed: slugify(form.title) || 'activo',
    status: 'PUBLISHED',
    offerType: form.offerType || null,
    headline: form.headline.trim() || null,
    sellReason: form.sellReason.trim() || null,
    sellerCompany: form.sellerCompany.trim() || null,
    sellerWebsite: form.sellerWebsite.trim() || null,
    sellerType: form.sellerType || null,
    mineralizationType: form.mineralizationType || null,
    works: form.works.join(', ') || null,
    waterAccess: form.waterAccess.trim() || null,
    energyAccess: form.energyAccess.trim() || null,
    esgEnvStatus: form.esgEnvStatus.trim() || null,
    esgClosurePlan: form.esgClosurePlan.trim() || null,
    esgCommunity: form.esgCommunity.trim() || null,
    esgLiabilities: form.esgLiabilities.trim() || null,
    contactName: form.contactName.trim() || null,
    contactRole: form.contactRole.trim() || null,
    contactEmail: form.contactEmail.trim() || null,
    contactPhone: form.contactPhone.trim() || null,
    contactPreference: form.contactPreference || null,
    hasAgent: form.hasAgent,
    commodities: { create: commodities },
    dealTypes: { create: form.dealTypes.map((d) => ({ dealType: d })) },
  }
}

type BuildResult = { ok: true; data: ReturnType<typeof toData> } | { ok: false; errors: string[] }

export function buildListingInput(form: WizardForm): BuildResult {
  const errors: string[] = []
  if (!form.title.trim()) errors.push('El nombre del activo es obligatorio.')
  if (!form.country.trim()) errors.push('El país es obligatorio.')
  if (form.commodities.length === 0) errors.push('Selecciona al menos un mineral.')
  if (form.dealTypes.length === 0) errors.push('Selecciona al menos una estructura de negocio.')
  if (errors.length > 0) return { ok: false, errors }
  return { ok: true, data: toData(form) }
}