<!-- nuxt4-app/app/components/ingresos/TopClientes.vue -->
<template>
  <UCard class="brand-card border border-transparent">
    <template #header>
      <div class="flex items-center justify-between gap-4">
        <div class="flex-1">
          <h2 class="text-xl font-bold brand-section-title">
            {{ viewModeTitle }}
          </h2>
          <p class="text-xs text-[var(--brand-text-muted)] mt-1">
            Clasificados por: <span class="font-semibold text-[var(--brand-primary)]">{{ categoriaActual.label }}</span>
          </p>

          <!-- Estadísticas de ranking -->
          <div class="flex items-center gap-2 mt-2 text-xs flex-wrap">
            <div v-if="rankingStats.clientesArriba > 0" class="inline-flex items-center gap-1.5 px-2 py-1 rounded bg-purple-500/10 border border-purple-500/30">
              <UIcon name="i-lucide-arrow-up" class="w-3 h-3 text-purple-400" />
              <span class="text-purple-300 font-semibold">{{ rankingStats.clientesArriba }}</span>
              <span class="text-[var(--brand-text-muted)]">arriba</span>
              <span class="text-purple-400 font-mono">({{ rankingStats.porcentajeArriba.toFixed(1) }}%)</span>
            </div>

            <div v-if="rankingStats.clientesAbajo > 0" class="inline-flex items-center gap-1.5 px-2 py-1 rounded bg-gray-500/10 border border-gray-500/30">
              <UIcon name="i-lucide-arrow-down" class="w-3 h-3 text-gray-400" />
              <span class="text-gray-300 font-semibold">{{ rankingStats.clientesAbajo }}</span>
              <span class="text-[var(--brand-text-muted)]">abajo</span>
              <span class="text-gray-400 font-mono">({{ rankingStats.porcentajeAbajo.toFixed(1) }}%)</span>
            </div>

            <div class="inline-flex items-center gap-1.5 px-2 py-1 rounded bg-[var(--brand-primary)]/10 border border-[var(--brand-primary)]/30">
              <UIcon name="i-lucide-users" class="w-3 h-3 text-[var(--brand-primary)]" />
              <span class="text-[var(--brand-primary)] font-semibold">{{ rankingStats.totalClientes }}</span>
              <span class="text-[var(--brand-text-muted)]">total</span>
            </div>

            <!-- Acumulado mostrado -->
            <div class="inline-flex items-center gap-1.5 px-2 py-1 rounded bg-green-500/10 border border-green-500/30">
              <UIcon name="i-lucide-trending-up" class="w-3 h-3 text-green-400" />
              <span class="text-green-400 font-semibold">{{ formatValue(acumulados.mostrados) }}</span>
              <span class="text-[var(--brand-text-muted)]">visible</span>
              <span class="text-green-400 font-mono">({{ acumulados.porcentajeMostrados.toFixed(1) }}%)</span>
            </div>

            <!-- Acumulado oculto -->
            <div v-if="acumulados.ocultos > 0" class="inline-flex items-center gap-1.5 px-2 py-1 rounded bg-orange-500/10 border border-orange-500/30">
              <UIcon name="i-lucide-trending-down" class="w-3 h-3 text-orange-400" />
              <span class="text-orange-400 font-semibold">{{ formatValue(acumulados.ocultos) }}</span>
              <span class="text-[var(--brand-text-muted)]">{{ viewMode === 'top' ? 'abajo' : viewMode === 'bottom' ? 'arriba' : 'fuera' }}</span>
              <span class="text-orange-400 font-mono">({{ acumulados.porcentajeOcultos.toFixed(1) }}%)</span>
            </div>
          </div>
        </div>
        <div class="flex items-center gap-2">
          <UInput
            v-model.number="cantidadClientes"
            type="number"
            :min="1"
            :max="100"
            size="sm"
            class="w-16"
            placeholder="10"
          />
          <div class="flex items-center gap-1 border border-[var(--brand-border)] rounded-md p-0.5">
            <UButton
              icon="i-lucide-arrow-down-wide-narrow"
              :color="viewMode === 'top' ? 'primary' : 'neutral'"
              :variant="viewMode === 'top' ? 'soft' : 'ghost'"
              size="xs"
              @click="viewMode = 'top'"
              title="Top N"
            >
              Top
            </UButton>
            <UButton
              icon="i-lucide-minus"
              :color="viewMode === 'average' ? 'warning' : 'neutral'"
              :variant="viewMode === 'average' ? 'soft' : 'ghost'"
              size="xs"
              @click="viewMode = 'average'"
              title="Average N*2+1"
            >
              Avg
            </UButton>
            <UButton
              icon="i-lucide-arrow-up-wide-narrow"
              :color="viewMode === 'bottom' ? 'error' : 'neutral'"
              :variant="viewMode === 'bottom' ? 'soft' : 'ghost'"
              size="xs"
              @click="viewMode = 'bottom'"
              title="Bottom N"
            >
              Bot
            </UButton>
          </div>
          <UInputMenu
            v-model="categoriaSeleccionada"
            :items="categorias"
            label-key="label"
            value-key="value"
            size="sm"
            icon="i-lucide-filter"
            placeholder="Seleccionar métrica"
          />
        </div>
      </div>
    </template>

    <div class="space-y-3">
      <div
        v-for="(item, index) in topClientes"
        :key="item.cliente.id"
        class="flex items-center gap-4 p-3 rounded-lg border border-[var(--brand-border)] bg-gradient-to-r from-[var(--brand-bg-secondary)] to-transparent hover:border-[var(--brand-primary)]/30 transition-all"
      >
        <!-- Ranking Badge -->
        <div
          :class="getRankingBadgeClass(index)"
        >
          {{ index + 1 }}
        </div>

        <!-- Cliente Info -->
        <div class="flex-1 min-w-0">
          <div class="font-semibold text-[var(--brand-text)] truncate">
            {{ item.cliente.name }}
          </div>
          <div class="text-xs text-[var(--brand-text-muted)] flex items-center gap-2">
            <span v-if="item.cliente.cedula" class="inline-flex items-center gap-1">
              <UIcon name="i-lucide-credit-card" class="w-3 h-3" />
              {{ item.cliente.cedula }}
            </span>
            <span v-if="item.cliente.ubicacion" class="inline-flex items-center gap-1">
              <UIcon name="i-lucide-map-pin" class="w-3 h-3" />
              {{ item.cliente.ubicacion }}
            </span>
          </div>
        </div>

        <!-- Metric Value -->
        <div class="flex-shrink-0 text-right min-w-[120px]">
          <div class="text-xs text-[var(--brand-text-muted)] uppercase tracking-wide mb-0.5">
            {{ categoriaActual.label }}
          </div>
          <div class="font-bold text-lg text-[var(--brand-primary)]">
            {{ formatValue(item.value) }}
          </div>
          <div class="text-xs text-[var(--brand-text-muted)]">
            {{ categoriaActual.unit }}
          </div>
        </div>
      </div>

      <!-- Empty State -->
      <div v-if="topClientes.length === 0" class="text-center py-8 text-[var(--brand-text-muted)]">
        <UIcon name="i-lucide-users-round" class="w-12 h-12 mx-auto mb-2 opacity-50" />
        <p>No hay datos disponibles para esta categoría</p>
        <p class="text-xs mt-1">{{ viewModeTitle }} - {{ categoriaActual.label }}</p>
      </div>
    </div>
  </UCard>
</template>

<script setup lang="ts">
import type { IngresoRecord } from '~/composables/useIngresosMetrics'

interface ClienteRecord {
  id: number
  name: string
  cedula?: number
  ubicacion?: string
  telefono?: string
  [key: string]: any
}

interface Props {
  ingresos: IngresoRecord[]
  clientes: ClienteRecord[]
}

const props = defineProps<Props>()

interface Categoria {
  value: string
  label: string
  unit: string
  calculate: (ingresos: IngresoRecord[]) => number
}

const categorias: Categoria[] = [
  {
    value: 'total-ingresos',
    label: 'Total de Ingresos',
    unit: 'registros',
    calculate: (ingresos) => ingresos.length
  },
  {
    value: 'peso-seco',
    label: 'Peso Seco Total',
    unit: 'qq',
    calculate: (ingresos) => ingresos.reduce((sum, i) => sum + (i.peso_seco || 0), 0)
  },
  {
    value: 'peso-neto',
    label: 'Peso Neto Total',
    unit: 'lb',
    calculate: (ingresos) => ingresos.reduce((sum, i) => sum + (i.peso_neto || 0), 0)
  },
  {
    value: 'inversion-total',
    label: 'Inversión Total',
    unit: 'L',
    calculate: (ingresos) => {
      return ingresos.reduce((sum, i) => {
        if (i.tipo === 'verde' || i.tipo === 'uva') {
          return sum + (i.precio * i.peso_neto)
        }
        if (i.tipo === 'oreado' || i.tipo === 'mojado') {
          return sum + ((i.precio / 2) * i.peso_seco)
        }
        return sum
      }, 0)
    }
  },
  {
    value: 'peso-uva',
    label: 'Peso Uva Total',
    unit: 'lb',
    calculate: (ingresos) => {
      return ingresos
        .filter(i => i.tipo === 'uva')
        .reduce((sum, i) => sum + (i.peso_neto || 0), 0)
    }
  },
  {
    value: 'peso-oreado',
    label: 'Peso Oreado Total',
    unit: 'qq',
    calculate: (ingresos) => {
      return ingresos
        .filter(i => i.tipo === 'oreado')
        .reduce((sum, i) => sum + (i.peso_seco || 0), 0)
    }
  },
  {
    value: 'peso-mojado',
    label: 'Peso Mojado Total',
    unit: 'qq',
    calculate: (ingresos) => {
      return ingresos
        .filter(i => i.tipo === 'mojado')
        .reduce((sum, i) => sum + (i.peso_seco || 0), 0)
    }
  },
  {
    value: 'peso-verde',
    label: 'Peso Verde Total',
    unit: 'lb',
    calculate: (ingresos) => {
      return ingresos
        .filter(i => i.tipo === 'verde')
        .reduce((sum, i) => sum + (i.peso_neto || 0), 0)
    }
  }
]

const categoriaSeleccionada = ref('total-ingresos')
const viewMode = ref<'top' | 'average' | 'bottom'>('top')
const cantidadClientes = ref(10)

const categoriaActual = computed(() => {
  return categorias.find(c => c.value === categoriaSeleccionada.value) ?? categorias[0]
})

const viewModeTitle = computed(() => {
  const cantidad = viewMode.value === 'average' ? cantidadClientes.value * 2 + 1 : cantidadClientes.value
  switch (viewMode.value) {
    case 'top':
      return `Top ${cantidadClientes.value} Clientes`
    case 'average':
      return `Average ${cantidad} Clientes`
    case 'bottom':
      return `Bottom ${cantidadClientes.value} Clientes`
    default:
      return `Top ${cantidadClientes.value} Clientes`
  }
})

interface TopClienteItem {
  cliente: ClienteRecord
  value: number
}

interface RankingStats {
  totalClientes: number
  clientesArriba: number
  clientesAbajo: number
  porcentajeArriba: number
  porcentajeAbajo: number
}

function getRankingBadgeClass(index: number): string {
  const baseClass = 'flex-shrink-0 w-8 h-8 rounded-full flex items-center justify-center font-bold text-sm'

  if (viewMode.value === 'average') {
    // En modo average, el índice central es el oro - DESTACADO
    const centralIndex = cantidadClientes.value
    if (index === centralIndex) {
      return `${baseClass} bg-yellow-500/30 text-yellow-400 border-2 border-yellow-500/70 shadow-lg shadow-yellow-500/50 scale-110`
    }

    // Posiciones antes del central: versiones más poderosas (degradado de morado a azul)
    if (index < centralIndex) {
      const normalizedPosition = index / centralIndex

      if (normalizedPosition < 0.2) {
        return `${baseClass} bg-purple-600/40 text-purple-200 border-2 border-purple-500/70 shadow-lg shadow-purple-500/30`
      } else if (normalizedPosition < 0.4) {
        return `${baseClass} bg-purple-500/35 text-purple-300 border-2 border-purple-400/60 shadow-md`
      } else if (normalizedPosition < 0.6) {
        return `${baseClass} bg-indigo-500/30 text-indigo-300 border-2 border-indigo-400/55 shadow`
      } else if (normalizedPosition < 0.8) {
        return `${baseClass} bg-blue-500/25 text-blue-300 border-2 border-blue-400/50`
      } else {
        return `${baseClass} bg-cyan-500/20 text-cyan-400 border border-cyan-400/45`
      }
    }

    // Posiciones después del central: versiones más básicas (degradado de gris a casi invisible)
    if (index > centralIndex) {
      const distanceFromCenter = index - centralIndex
      const normalizedDistance = distanceFromCenter / cantidadClientes.value

      if (normalizedDistance < 0.2) {
        return `${baseClass} bg-gray-400/20 text-gray-300 border border-gray-400/40`
      } else if (normalizedDistance < 0.4) {
        return `${baseClass} bg-gray-500/15 text-gray-400 border border-gray-500/35`
      } else if (normalizedDistance < 0.6) {
        return `${baseClass} bg-gray-600/10 text-gray-500 border border-gray-600/25`
      } else if (normalizedDistance < 0.8) {
        return `${baseClass} bg-gray-700/8 text-gray-600 border border-gray-700/20`
      } else {
        return `${baseClass} bg-gray-800/5 text-gray-700 border border-gray-800/15`
      }
    }
  }

  // Modo Top o Bottom (lógica normal)
  if (index === 0) {
    return `${baseClass} bg-yellow-500/20 text-yellow-400 border-2 border-yellow-500/50`
  }
  if (index === 1) {
    return `${baseClass} bg-gray-400/20 text-gray-300 border-2 border-gray-400/50`
  }
  if (index === 2) {
    return `${baseClass} bg-orange-500/20 text-orange-400 border-2 border-orange-500/50`
  }

  return `${baseClass} bg-[var(--brand-primary)]/10 text-[var(--brand-primary)] border border-[var(--brand-primary)]/30`
}

const topClientes = computed((): TopClienteItem[] => {
  // Agrupar ingresos por cliente
  const clienteMap = new Map<number, IngresoRecord[]>()

  props.ingresos.forEach(ingreso => {
    const clienteId = ingreso.cliente_id
    if (!clienteMap.has(clienteId)) {
      clienteMap.set(clienteId, [])
    }
    clienteMap.get(clienteId)!.push(ingreso)
  })

  // Calcular métrica para cada cliente
  const results: TopClienteItem[] = []

  clienteMap.forEach((ingresos, clienteId) => {
    const cliente = props.clientes.find(c => c.id === clienteId)
    if (!cliente) return

    // Calcular el valor usando la función de la categoría actual
    const value = categoriaActual.value.calculate(ingresos)

    results.push({ cliente, value })
  })

  // Ordenar descendente (mayor a menor) siempre
  const sorted = results.sort((a, b) => b.value - a.value)

  let finalResults: TopClienteItem[] = []

  // Seleccionar registros según el modo
  switch (viewMode.value) {
    case 'top':
      finalResults = sorted.slice(0, cantidadClientes.value)
      break

    case 'bottom':
      // Tomar los últimos N (inverso)
      finalResults = sorted.slice(-cantidadClientes.value).reverse()
      break

    case 'average':
      // Tomar N*2+1 clientes centrados (posición central es el oro)
      const totalClientes = sorted.length
      const totalAverage = cantidadClientes.value * 2 + 1
      if (totalClientes < totalAverage) {
        // Si hay menos del total, mostrar todos
        finalResults = sorted
      } else {
        // Calcular el índice central
        const midIndex = Math.floor(totalClientes / 2)
        // Tomar N antes, el central, y N después
        const startIndex = Math.max(0, midIndex - cantidadClientes.value)
        finalResults = sorted.slice(startIndex, startIndex + totalAverage)
      }
      break

    default:
      finalResults = sorted.slice(0, cantidadClientes.value)
  }

  // Debug log
  console.log(`${viewMode.value.toUpperCase()} Clientes - Categoría:`, categoriaActual.value.label)
  console.log(`${viewMode.value.toUpperCase()} Clientes - Top 3:`, finalResults.slice(0, 3).map(s => ({
    name: s.cliente.name,
    value: s.value,
    unit: categoriaActual.value.unit
  })))

  return finalResults
})

// Acumulados para header y footer
const acumulados = computed(() => {
  // Agrupar ingresos por cliente
  const clienteMap = new Map<number, IngresoRecord[]>()

  props.ingresos.forEach(ingreso => {
    const clienteId = ingreso.cliente_id
    if (!clienteMap.has(clienteId)) {
      clienteMap.set(clienteId, [])
    }
    clienteMap.get(clienteId)!.push(ingreso)
  })

  // Calcular métrica para cada cliente
  const allResults: TopClienteItem[] = []

  clienteMap.forEach((ingresos, clienteId) => {
    const cliente = props.clientes.find(c => c.id === clienteId)
    if (!cliente) return

    const value = categoriaActual.value.calculate(ingresos)
    allResults.push({ cliente, value })
  })

  // Ordenar descendente
  const sorted = allResults.sort((a, b) => b.value - a.value)

  // Calcular acumulados según el modo
  let acumuladoMostrados = 0
  let acumuladoOcultos = 0

  if (viewMode.value === 'top') {
    // Top N: sumar los primeros N
    const topItems = sorted.slice(0, cantidadClientes.value)
    const bottomItems = sorted.slice(cantidadClientes.value)

    acumuladoMostrados = topItems.reduce((sum, item) => sum + item.value, 0)
    acumuladoOcultos = bottomItems.reduce((sum, item) => sum + item.value, 0)
  } else if (viewMode.value === 'bottom') {
    // Bottom N: sumar los últimos N
    const bottomItems = sorted.slice(-cantidadClientes.value)
    const topItems = sorted.slice(0, -cantidadClientes.value)

    acumuladoMostrados = bottomItems.reduce((sum, item) => sum + item.value, 0)
    acumuladoOcultos = topItems.reduce((sum, item) => sum + item.value, 0)
  } else if (viewMode.value === 'average') {
    // Average N*2+1: sumar los del medio
    const totalClientes = sorted.length
    const totalAverage = cantidadClientes.value * 2 + 1
    if (totalClientes < totalAverage) {
      acumuladoMostrados = sorted.reduce((sum, item) => sum + item.value, 0)
      acumuladoOcultos = 0
    } else {
      const midIndex = Math.floor(totalClientes / 2)
      const startIndex = Math.max(0, midIndex - cantidadClientes.value)
      const avgItems = sorted.slice(startIndex, startIndex + totalAverage)
      const otherItems = [...sorted.slice(0, startIndex), ...sorted.slice(startIndex + totalAverage)]

      acumuladoMostrados = avgItems.reduce((sum, item) => sum + item.value, 0)
      acumuladoOcultos = otherItems.reduce((sum, item) => sum + item.value, 0)
    }
  }

  const totalAcumulado = acumuladoMostrados + acumuladoOcultos
  const porcentajeMostrados = totalAcumulado > 0 ? (acumuladoMostrados / totalAcumulado) * 100 : 0
  const porcentajeOcultos = totalAcumulado > 0 ? (acumuladoOcultos / totalAcumulado) * 100 : 0

  return {
    mostrados: acumuladoMostrados,
    ocultos: acumuladoOcultos,
    porcentajeMostrados,
    porcentajeOcultos
  }
})

const rankingStats = computed((): RankingStats => {
  // Agrupar todos los clientes primero para obtener el total
  const clienteMap = new Map<number, IngresoRecord[]>()

  props.ingresos.forEach(ingreso => {
    const clienteId = ingreso.cliente_id
    if (!clienteMap.has(clienteId)) {
      clienteMap.set(clienteId, [])
    }
    clienteMap.get(clienteId)!.push(ingreso)
  })

  const totalClientes = clienteMap.size

  let clientesArriba = 0
  let clientesAbajo = 0

  if (viewMode.value === 'top') {
    // En Top N, todos los demás están abajo
    clientesArriba = 0
    clientesAbajo = Math.max(0, totalClientes - cantidadClientes.value)
  } else if (viewMode.value === 'bottom') {
    // En Bottom N, todos los demás están arriba
    clientesArriba = Math.max(0, totalClientes - cantidadClientes.value)
    clientesAbajo = 0
  } else if (viewMode.value === 'average') {
    // En Average N*2+1, calcular cuántos hay arriba y abajo
    const totalAverage = cantidadClientes.value * 2 + 1
    if (totalClientes <= totalAverage) {
      clientesArriba = 0
      clientesAbajo = 0
    } else {
      const midIndex = Math.floor(totalClientes / 2)
      const startIndex = Math.max(0, midIndex - cantidadClientes.value)
      const endIndex = startIndex + totalAverage

      clientesArriba = startIndex
      clientesAbajo = Math.max(0, totalClientes - endIndex)
    }
  }

  const porcentajeArriba = totalClientes > 0 ? (clientesArriba / totalClientes) * 100 : 0
  const porcentajeAbajo = totalClientes > 0 ? (clientesAbajo / totalClientes) * 100 : 0

  return {
    totalClientes,
    clientesArriba,
    clientesAbajo,
    porcentajeArriba,
    porcentajeAbajo
  }
})

function formatValue(value: number): string {
  const unit = categoriaActual.value.unit

  if (unit === 'L') {
    // Formato monetario
    return new Intl.NumberFormat('es-HN', {
      style: 'currency',
      currency: 'HNL',
      minimumFractionDigits: 2,
      maximumFractionDigits: 2
    }).format(value).replace('HNL', 'L')
  }

  if (unit === 'registros') {
    return value.toString()
  }

  // Formato numérico con decimales
  return value.toLocaleString('es-HN', {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2
  })
}
</script>
