"use client"

export type WalletTransactionType = "booking" | "tip" | "payout" | "refund" | "adjustment"

export interface WalletTransaction {
  id: string
  vendorId: string
  type: WalletTransactionType
  amount: number
  /** Positive = inflow, negative = outflow */
  sign: 1 | -1
  description: string
  referenceId?: string
  createdAt: string
}

export interface WalletPayout {
  id: string
  vendorId: string
  amount: number
  status: "pending" | "completed" | "failed"
  scheduledFor: string
  completedAt?: string
  createdAt: string
}

const TX_KEY = "beachlyfe_vendor_wallet_tx_v1"
const PAYOUTS_KEY = "beachlyfe_vendor_wallet_payouts_v1"

function canUse() {
  return typeof window !== "undefined" && window.localStorage != null
}

function genId(prefix: string) {
  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`
}

function getTx(): WalletTransaction[] {
  if (!canUse()) return []
  try {
    const raw = localStorage.getItem(TX_KEY)
    return raw ? JSON.parse(raw) : []
  } catch {
    return []
  }
}

function saveTx(list: WalletTransaction[]) {
  localStorage.setItem(TX_KEY, JSON.stringify(list))
}

function getPayouts(): WalletPayout[] {
  if (!canUse()) return []
  try {
    const raw = localStorage.getItem(PAYOUTS_KEY)
    return raw ? JSON.parse(raw) : []
  } catch {
    return []
  }
}

export function getVendorTransactions(vendorId: string, limit = 100): WalletTransaction[] {
  return getTx()
    .filter((t) => t.vendorId === vendorId)
    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
    .slice(0, limit)
}

export function getVendorPayouts(vendorId: string): WalletPayout[] {
  return getPayouts()
    .filter((p) => p.vendorId === vendorId)
    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
}

export function getVendorWalletSummary(vendorId: string): {
  availableBalance: number
  pendingBalance: number
  nextPayoutDate: string | null
  nextPayoutAmount: number
} {
  const tx = getTx().filter((t) => t.vendorId === vendorId)
  const payouts = getPayouts().filter((p) => p.vendorId === vendorId)
  const totalInflow = tx.filter((t) => t.sign === 1).reduce((s, t) => s + t.amount, 0)
  const totalOutflow = tx.filter((t) => t.sign === -1).reduce((s, t) => s + t.amount, 0)
  const completedPayouts = payouts.filter((p) => p.status === "completed").reduce((s, p) => s + p.amount, 0)
  const availableBalance = Math.max(0, totalInflow - totalOutflow - completedPayouts)
  const pendingBalance = 0
  const nextMonday = (() => {
    const d = new Date()
    const day = d.getDay()
    const toAdd = day === 0 ? 1 : day === 1 ? 7 : 8 - day
    d.setDate(d.getDate() + toAdd)
    return d.toISOString().slice(0, 10)
  })()
  return {
    availableBalance,
    pendingBalance,
    nextPayoutDate: nextMonday,
    nextPayoutAmount: availableBalance,
  }
}

/** Add a payout record (e.g. for demo or admin). */
export function addVendorPayout(
  vendorId: string,
  data: Omit<WalletPayout, "id" | "vendorId" | "createdAt">
): WalletPayout {
  const payout: WalletPayout = {
    ...data,
    id: genId("payout"),
    vendorId,
    createdAt: new Date().toISOString(),
  }
  const list = getPayouts()
  list.push(payout)
  localStorage.setItem(PAYOUTS_KEY, JSON.stringify(list))
  return payout
}

/** Called when a booking is completed to add a transaction (optional). */
export function addBookingTransaction(
  vendorId: string,
  bookingId: string,
  amount: number,
  tip: number
): void {
  const list = getTx()
  if (amount > 0) {
    list.push({
      id: genId("tx"),
      vendorId,
      type: "booking",
      amount,
      sign: 1,
      description: "Booking payment",
      referenceId: bookingId,
      createdAt: new Date().toISOString(),
    })
  }
  if (tip > 0) {
    list.push({
      id: genId("tx"),
      vendorId,
      type: "tip",
      amount: tip,
      sign: 1,
      description: "Tip",
      referenceId: bookingId,
      createdAt: new Date().toISOString(),
    })
  }
  saveTx(list)
}