Transformaciones de Datos

// cannahub-webapp/src/lib/medusa/
├── client.ts          // Config SDK
├── products.ts        // Productos
├── customer.ts        // Clientes → Users
├── customerGroup.ts   // Groups → Memberships
├── cart.ts            // Carritos
├── categories.ts      // Categorías
├── priceList.ts       // Listas de precios
├── user.ts            // Staff/Admin
└── notifications.ts   // Notificaciones

// Medusa Customer (raw)
interface MedusaCustomer {
  id: string
  first_name: string
  last_name: string
  email: string
  created_at: string
  updated_at: string
  metadata: Record<string, any>
}

// Cannahub User (transformado)
interface User {
  id: string
  firstName: string
  lastName: string
  email: string
  createdAt: Date
  updatedAt: Date
  // metadata extraído a propiedades
}

function parseMedusaCustomer(
  medusa: MedusaCustomer
): User {
  return {
    id: medusa.id,
    email: medusa.email,
    firstName: medusa.first_name,
    lastName: medusa.last_name,

    // Extraído de metadata
    status: medusa.metadata?.status
      ?? MemberStatus.INVITED,
    medicalRecord: medusa.metadata?.medicalRecord,
    membership: medusa.metadata?.membership,
    onboardingStep: medusa.metadata?.onboardingStep,
    hasReprocann: medusa.metadata?.hasReprocann
      ?? false,

    createdAt: new Date(medusa.created_at),
    updatedAt: new Date(medusa.updated_at),
  }
}

import { parse, parseISO } from 'date-fns'

// Fecha ISO estándar de Medusa
const createdAt = parseISO(medusa.created_at)

// Fecha en formato local (metadata)
function parseDateString(
  dateStr: string
): Date | undefined {
  if (!dateStr) return undefined

  // Intentar formato DD/MM/YYYY
  const localDate = parse(
    dateStr,
    'dd/MM/yyyy',
    new Date()
  )
  if (!isNaN(localDate.getTime())) {
    return localDate
  }

  // Fallback a ISO
  return parseISO(dateStr)
}

// Uso para REPROCANN expiration
const expiration = parseDateString(
  medusa.metadata?.reprocannExpiration
)

function parseVariantPrices(
  prices: MedusaPrice[]
): VariantPricing {
  // Filtrar por moneda
  const arsPrices = prices.filter(
    p => p.currency_code === 'ars'
  )

  // Precio base (sin price list)
  const basePrice = arsPrices.find(
    p => !p.price_list_id
  )

  // Precio con descuento (de price list)
  const discountedPrice = arsPrices.find(
    p => p.price_list_id
  )

  const price = basePrice?.amount ?? 0
  const discountPrice = discountedPrice?.amount

  return {
    price: price / 100, // Medusa usa centavos
    discountPrice: discountPrice
      ? discountPrice / 100
      : undefined,
    discountPercentage: discountPrice
      ? Math.round(
          (1 - discountPrice / price) * 100
        )
      : undefined
  }
}

function calculateInventoryTotal(
  variant: MedusaVariant,
  inventoryQuantity: number
): number {
  // Obtener peso de metadata
  const weight = variant.metadata?.weight
    ?? variant.metadata?.quantity
    ?? 1

  // Multiplicar para obtener total en gramos
  return inventoryQuantity * weight
}

// Uso en transformación de variante
const variant: ProductVariant = {
  id: medusa.id,
  name: medusa.title,
  weight: medusa.metadata?.weight ?? 1,
  inventoryQuantity: medusa.inventory_quantity,
  inventoryTotal: calculateInventoryTotal(
    medusa,
    medusa.inventory_quantity
  ),
  // ...
}

function parseProductStrain(
  metadata: Record<string, any>
): Strain | undefined {
  // Patrón legacy: objeto completo
  if (metadata?.strain?.id) {
    return {
      id: metadata.strain.id,
      name: metadata.strain.name,
      type: metadata.strain.type,
      cannabinoids: metadata.strain.cannabinoids,
      // ...
    }
  }

  // Patrón nuevo: referencia ligera
  if (metadata?.strainId) {
    return {
      id: metadata.strainId,
      name: metadata.strainName ?? 'Unknown',
      type: metadata.strainType ?? 'hybrid',
      // Requiere fetch adicional para datos completos
    }
  }

  return undefined
}

export function parseMedusaCustomer(
  customer: MedusaCustomer
): User {
  const { metadata } = customer

  return {
    id: customer.id,
    email: customer.email,
    firstName: customer.first_name ?? '',
    lastName: customer.last_name ?? '',
    phone: customer.phone ?? '',

    role: metadata?.role ?? Role.MEMBER,
    status: metadata?.status
      ?? MemberStatus.INVITED,

    medicalRecord: metadata?.medicalRecord,
    membership: metadata?.membership,
    onboardingStep: metadata?.onboardingStep,
    hasReprocann: metadata?.hasReprocann ?? false,

    addresses: (customer.addresses ?? [])
      .map(parseAddress),

    createdAt: new Date(customer.created_at),
    updatedAt: new Date(customer.updated_at),
  }
}

export function parseMedusaProduct(
  product: MedusaProduct
): Product {
  const { metadata } = product

  const variants = (product.variants ?? [])
    .map(parseMedusaVariant)

  // Calcular precio más bajo
  const lowestPrice = Math.min(
    ...variants.map(v => v.price)
  )

  return {
    id: product.id,
    name: product.title,
    description: product.description ?? '',
    handle: product.handle,
    status: product.status,

    imageUrl: product.thumbnail ?? '',
    images: (product.images ?? [])
      .map(img => img.url),

    variants,
    strain: parseProductStrain(metadata),
    isFlower: metadata?.isFlower ?? false,

    category: product.categories?.[0]?.name
      ?? 'Sin categoría',
    price: lowestPrice,
    currency: 'ARS',

    inventoryQuantity: variants.reduce(
      (sum, v) => sum + v.inventoryQuantity,
      0
    ),
  }
}

export function parseMedusaOrder(
  order: MedusaOrder
): Order {
  return {
    id: order.id,
    displayId: String(order.display_id),

    status: order.status,
    fulfillmentStatus: order.fulfillment_status,
    paymentStatus: order.payment_status,

    customer: parseMedusaCustomer(order.customer),

    items: (order.items ?? []).map(item => ({
      id: item.id,
      title: item.title,
      thumbnail: item.thumbnail,
      variantId: item.variant_id,
      quantity: item.quantity,
      unitPrice: item.unit_price / 100,
      total: item.total / 100,
    })),

    payments: parsePaymentCollections(
      order.payment_collections
    ),

    subtotal: order.subtotal / 100,
    shippingTotal: order.shipping_total / 100,
    taxTotal: order.tax_total / 100,
    total: order.total / 100,
    currency: order.currency_code?.toUpperCase()
      ?? 'ARS',

    shippingAddress: order.shipping_address
      ? parseAddress(order.shipping_address)
      : undefined,

    activityLogs: order.metadata?.activity_logs,

    createdAt: new Date(order.created_at),
    updatedAt: new Date(order.updated_at),
  }
}

export function parseMedusaCustomerGroup(
  group: MedusaCustomerGroup
): Membership {
  const { metadata } = group

  return {
    id: group.id,
    name: group.name,
    description: metadata?.description ?? '',
    price: metadata?.price ?? 0,
    currency: 'ARS',

    benefits: metadata?.benefits ?? [],
    limits: metadata?.limits,

    priceListId: metadata?.priceListId ?? '',
    isActive: metadata?.isActive ?? true,
    sortOrder: metadata?.sortOrder ?? 0,
    color: metadata?.color,

    metadata: metadata ?? {},
  }
}