import type { RowDataPacket } from 'mysql2'
import { db, DB } from './db'

/**
 * Un movimiento del historial de PD/PV. Los textos visibles se devuelven como
 * CLAVES para que la página los traduzca (i18n): `method`, `status` y el concepto
 * (`conceptKey` + `conceptArgs`, con `conceptRaw` de reserva para textos libres
 * heredados que no tienen clave).
 */
export interface PointsMovement {
  date: Date
  conceptKey: string | null // p.ej. 'pd','vote','promo','rename','gold'…
  conceptArgs: Record<string, string | number>
  conceptRaw: string // reserva (product_name) cuando conceptKey es null
  method: 'Stripe' | 'SumUp' | 'vote' | 'promo'
  pd: number | null
  pv: number | null
  amount: number | null // € (pagos), null si no aplica
  status: 'delivered' | 'pending' | 'credited'
}

/** Slug de servicio (home_stripelog.service) -> clave de concepto traducible. */
const SERVICE_CONCEPT: Record<string, string> = {
  rename: 'rename',
  customize: 'customize',
  'change-race': 'changeRace',
  'change-faction': 'changeFaction',
  'level-up': 'levelUp',
  gold: 'gold',
  transfer: 'transfer',
  'restore-item': 'restoreItem',
  'send-gift': 'sendGift',
}

/** Saldos actuales de PD y PV de una cuenta de juego. */
export async function getPointsBalances(accountId: number): Promise<{ dp: number; pv: number }> {
  if (!accountId) return { dp: 0, pv: 0 }
  try {
    const [rows] = await db(DB.default).query<RowDataPacket[]>(
      'SELECT dp, vp FROM home_api_points WHERE accountID = ?',
      [accountId],
    )
    return rows[0] ? { dp: Number(rows[0].dp), pv: Number(rows[0].vp) } : { dp: 0, pv: 0 }
  } catch {
    return { dp: 0, pv: 0 }
  }
}

/** PD acreditados por un pago (si es una compra de PD), o null si es un servicio/ítem. */
function purchasedPD(productName: string, service: string | null, metadata: string | null): number | null {
  const m = /(\d+)\s*PD\b/i.exec(productName || '')
  if (m) return Number(m[1])
  if (service === 'dpoints') {
    try {
      const p = metadata ? JSON.parse(metadata).points : null
      return p ? Number(p) : null
    } catch {
      return null
    }
  }
  return null
}

/**
 * Historial unificado de PD/PV de una cuenta, combinando las fuentes reales:
 *  - `home_stripelog`: pagos por **Stripe** (mode test/live) y **SumUp** (mode sumup).
 *  - `home_votelog` (+ `home_votesite`): PV ganados al votar.
 *  - `home_promoredemption` (+ `home_promocode`): PD/PV canjeados por código.
 * Ordenado por fecha descendente; cada consulta es tolerante a fallos.
 */
export async function getPointsHistory(accountId: number, limit = 100): Promise<PointsMovement[]> {
  if (!accountId) return []
  const movements: PointsMovement[] = []

  // 1) Pagos (Stripe + SumUp).
  try {
    const [rows] = await db(DB.default).query<RowDataPacket[]>(
      'SELECT product_name, character_name, amount, mode, service, metadata, fulfilled, timestamp ' +
        'FROM home_stripelog WHERE account_id = ? ORDER BY timestamp DESC LIMIT ?',
      [accountId, limit],
    )
    for (const r of rows) {
      const service = r.service ? String(r.service) : null
      const productName = String(r.product_name || '—')
      const pd = purchasedPD(productName, service, r.metadata ? String(r.metadata) : null)

      // Concepto traducible: compra de PD -> "{n} PD"; servicio conocido ->
      // "{etiqueta}: {personaje}"; en otro caso, texto libre heredado.
      let conceptKey: string | null = null
      let conceptArgs: Record<string, string | number> = {}
      if (pd != null && (service === 'dpoints' || service === null)) {
        conceptKey = 'pd'
        conceptArgs = { n: pd }
      } else if (service && SERVICE_CONCEPT[service]) {
        conceptKey = SERVICE_CONCEPT[service]
        conceptArgs = { detail: String(r.character_name || '') }
      }

      movements.push({
        date: new Date(r.timestamp),
        conceptKey,
        conceptArgs,
        conceptRaw: productName,
        method: r.mode === 'sumup' ? 'SumUp' : 'Stripe',
        pd,
        pv: null,
        amount: Number(r.amount),
        status: r.fulfilled ? 'delivered' : 'pending',
      })
    }
  } catch {
    /* tabla ausente: se omite */
  }

  // 2) Votos (PV).
  try {
    const [rows] = await db(DB.default).query<RowDataPacket[]>(
      'SELECT v.created_at, s.name, s.points FROM home_votelog v ' +
        'JOIN home_votesite s ON s.id = v.vote_site_id WHERE v.account_id = ? ORDER BY v.created_at DESC LIMIT ?',
      [accountId, limit],
    )
    for (const r of rows) {
      movements.push({
        date: new Date(r.created_at),
        conceptKey: 'vote',
        conceptArgs: { detail: String(r.name || '') },
        conceptRaw: `Voto en ${r.name}`,
        method: 'vote',
        pd: null,
        pv: Number(r.points) || 0,
        amount: null,
        status: 'credited',
      })
    }
  } catch {
    /* tabla ausente: se omite */
  }

  // 3) Promociones (PD/PV).
  try {
    const [rows] = await db(DB.default).query<RowDataPacket[]>(
      'SELECT r.redeemed_at, c.code, c.pd, c.pv FROM home_promoredemption r ' +
        'JOIN home_promocode c ON c.id = r.promo_id WHERE r.account_id = ? ORDER BY r.redeemed_at DESC LIMIT ?',
      [accountId, limit],
    )
    for (const r of rows) {
      movements.push({
        date: new Date(r.redeemed_at),
        conceptKey: 'promo',
        conceptArgs: { detail: String(r.code || '') },
        conceptRaw: `Código ${r.code}`,
        method: 'promo',
        pd: Number(r.pd) > 0 ? Number(r.pd) : null,
        pv: Number(r.pv) > 0 ? Number(r.pv) : null,
        amount: null,
        status: 'credited',
      })
    }
  } catch {
    /* tabla ausente: se omite */
  }

  movements.sort((a, b) => b.date.getTime() - a.date.getTime())
  return movements.slice(0, limit)
}