const CACHE_NAME = 'daumis-debt-v1';
const ASSETS = [
  '/daumis-debt/',
  '/daumis-debt/index.html',
  '/daumis-debt/css/style.css',
  '/daumis-debt/js/app.js',
  '/daumis-debt/js/firebase-config.js',
  '/daumis-debt/js/exchange.js',
  '/daumis-debt/js/balance.js',
  '/daumis-debt/js/expenses.js',
  '/daumis-debt/js/payments.js',
  '/daumis-debt/js/history.js',
  '/daumis-debt/js/duel.js',
  '/daumis-debt/js/games/coin-flip.js',
  '/daumis-debt/js/games/wheel.js',
  '/daumis-debt/js/games/rps.js',
  '/daumis-debt/js/games/lucky-number.js',
  '/daumis-debt/js/games/scratch-card.js',
  '/daumis-debt/manifest.json'
];

self.addEventListener('install', (e) => {
  e.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(ASSETS)));
  self.skipWaiting();
});

self.addEventListener('activate', (e) => {
  e.waitUntil(
    caches.keys().then((keys) =>
      Promise.all(keys.filter((k) => k !== CACHE_NAME).map((k) => caches.delete(k)))
    )
  );
  self.clients.claim();
});

self.addEventListener('fetch', (e) => {
  // Network-first for API calls, cache-first for app shell
  if (e.request.url.includes('firestore.googleapis.com') ||
      e.request.url.includes('frankfurter.app') ||
      e.request.url.includes('googleapis.com/identitytoolkit')) {
    return; // Let network handle Firebase and API calls
  }
  e.respondWith(
    caches.match(e.request).then((cached) => cached || fetch(e.request))
  );
});

// Firebase configuration — these values are public by design.
// Security is enforced by Firestore rules, not by hiding this config.
const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_PROJECT.firebaseapp.com",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_PROJECT.appspot.com",
  messagingSenderId: "YOUR_SENDER_ID",
  appId: "YOUR_APP_ID"
};

firebase.initializeApp(firebaseConfig);

export const auth = firebase.auth();
export const db = firebase.firestore();
export const googleProvider = new firebase.auth.GoogleAuthProvider();

import { auth, googleProvider } from './firebase-config.js';

// --- State ---
let currentUser = null;
let partnerInfo = null; // { uid, name, email } — resolved after first data load

// User name mapping — populated after auth. Keys are UIDs, values are display names.
const userNames = {};

// --- Auth ---
document.getElementById('btn-google-login').addEventListener('click', () => {
  auth.signInWithPopup(googleProvider).catch((err) => {
    console.error('Auth error:', err);
    alert('Sign-in failed. Make sure you use an authorized Google account.');
  });
});

auth.onAuthStateChanged((user) => {
  if (user) {
    currentUser = user;
    userNames[user.uid] = user.displayName || user.email;
    showApp();
  } else {
    currentUser = null;
    showScreen('auth');
    document.getElementById('bottom-nav').classList.add('hidden');
  }
});

// --- Routing ---
function showScreen(name) {
  document.querySelectorAll('.screen').forEach((s) => s.classList.remove('active'));
  document.getElementById(`screen-${name}`).classList.add('active');
  document.querySelectorAll('.nav-btn').forEach((b) => {
    b.classList.toggle('active', b.dataset.screen === name);
  });
}

document.querySelectorAll('.nav-btn').forEach((btn) => {
  btn.addEventListener('click', () => {
    showScreen(btn.dataset.screen);
    if (btn.dataset.screen === 'dashboard') loadDashboard();
    if (btn.dataset.screen === 'history') loadHistory();
  });
});

// --- Toggle buttons ---
document.querySelectorAll('.toggle').forEach((toggle) => {
  toggle.querySelectorAll('.toggle-btn').forEach((btn) => {
    btn.addEventListener('click', () => {
      toggle.querySelectorAll('.toggle-btn').forEach((b) => b.classList.remove('active'));
      btn.classList.add('active');
    });
  });
});

// --- App entry ---
async function showApp() {
  document.getElementById('bottom-nav').classList.remove('hidden');
  // Set default dates to today
  const today = new Date().toISOString().split('T')[0];
  document.getElementById('expense-date').value = today;
  document.getElementById('payment-date').value = today;
  // Load dashboard
  showScreen('dashboard');
  const { loadDashboard } = await import('./balance.js');
  loadDashboard();
}

// Expose for other modules
export { currentUser, userNames, showScreen };
export function getCurrentUser() { return currentUser; }
export function getPartnerUid() {
  // Find the other user's UID from userNames
  return Object.keys(userNames).find((uid) => uid !== currentUser.uid) || null;
}
export function getUserName(uid) {
  return userNames[uid] || 'Partner';
}
export function setPartnerInfo(uid, name) {
  userNames[uid] = name;
}

// Exchange rate cache — avoids repeated API calls in a single session
const rateCache = {};

/**
 * Get exchange rate from a currency to USD.
 * Uses frankfurter.app (ECB data, free, no API key).
 * Returns the rate (multiply by this to get USD).
 * For USD → USD, returns 1.
 * Note: BTN is pegged 1:1 to INR. frankfurter.app doesn't support BTN,
 * so we use INR rate as a proxy.
 */
export async function getExchangeRate(currency) {
  if (currency === 'USD') return 1;

  const cacheKey = currency;
  if (rateCache[cacheKey]) return rateCache[cacheKey];

  // BTN (Bhutanese Ngultrum) is pegged 1:1 to INR
  const queryCurrency = currency === 'BTN' ? 'INR' : currency;

  const response = await fetch(
    `https://api.frankfurter.app/latest?from=${queryCurrency}&to=USD`
  );

  if (!response.ok) {
    throw new Error(`Exchange rate fetch failed for ${currency}`);
  }

  const data = await response.json();
  const rate = data.rates.USD;
  rateCache[cacheKey] = rate;
  return rate;
}

/**
 * Convert an amount in a given currency to USD.
 * Returns { usdAmount, exchangeRate }.
 */
export async function convertToUSD(amount, currency) {
  const exchangeRate = await getExchangeRate(currency);
  return {
    usdAmount: Math.round(amount * exchangeRate * 100) / 100,
    exchangeRate
  };
}

import('./js/exchange.js').then(m => m.convertToUSD(1000, 'THB').then(console.log));

import { db } from './firebase-config.js';
import { getCurrentUser, getPartnerUid, setPartnerInfo } from './app.js';
import { convertToUSD } from './exchange.js';

const form = document.getElementById('form-expense');

form.addEventListener('submit', async (e) => {
  e.preventDefault();
  const user = getCurrentUser();
  if (!user) return;

  const description = document.getElementById('expense-desc').value.trim();
  const amount = parseFloat(document.getElementById('expense-amount').value);
  const currency = document.getElementById('expense-currency').value;
  const paidByValue = document.querySelector('#expense-paid-by .toggle-btn.active').dataset.value;
  const splitType = document.querySelector('#expense-split .toggle-btn.active').dataset.value;
  const date = document.getElementById('expense-date').value;

  if (!description || !amount || amount <= 0) {
    alert('Please fill in all fields.');
    return;
  }

  const submitBtn = form.querySelector('button[type="submit"]');
  submitBtn.disabled = true;
  submitBtn.textContent = 'Saving...';

  try {
    const { usdAmount, exchangeRate } = await convertToUSD(amount, currency);
    const paidBy = paidByValue === 'self' ? user.uid : getPartnerUid();
    const owedBy = paidByValue === 'self' ? getPartnerUid() : user.uid;

    await db.collection('expenses').add({
      description,
      amount,
      currency,
      usdAmount,
      exchangeRate,
      paidBy,
      splitType,
      owedBy,
      date: new Date(date + 'T12:00:00'),
      addedBy: user.uid,
      createdAt: firebase.firestore.FieldValue.serverTimestamp()
    });

    form.reset();
    document.getElementById('expense-date').value = new Date().toISOString().split('T')[0];
    // Reset toggles to default
    document.querySelectorAll('#expense-paid-by .toggle-btn').forEach((b, i) =>
      b.classList.toggle('active', i === 0)
    );
    document.querySelectorAll('#expense-split .toggle-btn').forEach((b, i) =>
      b.classList.toggle('active', i === 0)
    );
    alert('Expense saved!');
  } catch (err) {
    console.error('Error saving expense:', err);
    alert('Failed to save expense. Check your connection.');
  } finally {
    submitBtn.disabled = false;
    submitBtn.textContent = 'Save Expense';
  }
});

/** Fetch all expenses ordered by date descending. */
export async function getAllExpenses() {
  const snapshot = await db.collection('expenses').orderBy('date', 'desc').get();
  return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }));
}

import { db } from './firebase-config.js';
import { getCurrentUser, getPartnerUid } from './app.js';
import { convertToUSD } from './exchange.js';

const form = document.getElementById('form-payment');

form.addEventListener('submit', async (e) => {
  e.preventDefault();
  const user = getCurrentUser();
  if (!user) return;

  const amount = parseFloat(document.getElementById('payment-amount').value);
  const currency = document.getElementById('payment-currency').value;
  const directionValue = document.querySelector('#payment-direction .toggle-btn.active').dataset.value;
  const date = document.getElementById('payment-date').value;

  if (!amount || amount <= 0) {
    alert('Please enter a valid amount.');
    return;
  }

  const submitBtn = form.querySelector('button[type="submit"]');
  submitBtn.disabled = true;
  submitBtn.textContent = 'Saving...';

  try {
    const { usdAmount, exchangeRate } = await convertToUSD(amount, currency);
    const paidBy = directionValue === 'self' ? user.uid : getPartnerUid();
    const paidTo = directionValue === 'self' ? getPartnerUid() : user.uid;

    await db.collection('payments').add({
      amount,
      currency,
      usdAmount,
      exchangeRate,
      paidBy,
      paidTo,
      date: new Date(date + 'T12:00:00'),
      addedBy: user.uid,
      createdAt: firebase.firestore.FieldValue.serverTimestamp()
    });

    form.reset();
    document.getElementById('payment-date').value = new Date().toISOString().split('T')[0];
    document.querySelectorAll('#payment-direction .toggle-btn').forEach((b, i) =>
      b.classList.toggle('active', i === 0)
    );
    alert('Payment recorded!');
  } catch (err) {
    console.error('Error saving payment:', err);
    alert('Failed to save payment. Check your connection.');
  } finally {
    submitBtn.disabled = false;
    submitBtn.textContent = 'Save Payment';
  }
});

/** Fetch all payments ordered by date descending. */
export async function getAllPayments() {
  const snapshot = await db.collection('payments').orderBy('date', 'desc').get();
  return snapshot.docs.map((doc) => ({ id: doc.id, ...doc.data() }));
}

import { db } from './firebase-config.js';
import { getCurrentUser, getPartnerUid, getUserName, setPartnerInfo } from './app.js';

/**
 * Compute net balance from all expenses, payments, and duels.
 * Returns a number: positive means the current user is owed money,
 * negative means the current user owes money.
 */
export async function computeBalance() {
  const user = getCurrentUser();
  let balance = 0; // positive = current user is owed

  // Process expenses
  const expenses = await db.collection('expenses').get();
  expenses.forEach((doc) => {
    const e = doc.data();
    // Track partner info for display
    if (e.paidBy !== user.uid) setPartnerInfo(e.paidBy, e.paidByName || 'Partner');
    if (e.owedBy && e.owedBy !== user.uid) setPartnerInfo(e.owedBy, '');

    if (e.splitType === 'even') {
      // paidBy is owed half by the other person
      if (e.paidBy === user.uid) {
        balance += e.usdAmount / 2; // partner owes me half
      } else {
        balance -= e.usdAmount / 2; // I owe partner half
      }
    } else {
      // "full" — owedBy owes the full amount to paidBy
      if (e.paidBy === user.uid && e.owedBy !== user.uid) {
        balance += e.usdAmount; // partner owes me full
      } else if (e.owedBy === user.uid && e.paidBy !== user.uid) {
        balance -= e.usdAmount; // I owe partner full
      }
    }
  });

  // Process payments
  const payments = await db.collection('payments').get();
  payments.forEach((doc) => {
    const p = doc.data();
    if (p.paidBy !== user.uid) setPartnerInfo(p.paidBy, '');
    if (p.paidTo !== user.uid) setPartnerInfo(p.paidTo, '');

    if (p.paidBy === user.uid) {
      balance += p.usdAmount; // I paid partner, so they owe me more (or I owe less)
    } else {
      balance -= p.usdAmount; // Partner paid me
    }
  });

  // Process duels
  const duels = await db.collection('duels').get();
  duels.forEach((doc) => {
    const d = doc.data();
    if (d.favoredUser === user.uid) {
      balance += d.balanceAdjust;
    } else if (d.favoredUser) {
      balance -= d.balanceAdjust;
    }
  });

  return Math.round(balance * 100) / 100;
}

/**
 * Load and render the dashboard.
 */
export async function loadDashboard() {
  const user = getCurrentUser();
  const balanceEl = document.getElementById('balance-display');

  try {
    const balance = await computeBalance();
    const label = balanceEl.querySelector('.balance-label');
    const amount = balanceEl.querySelector('.balance-amount');

    if (balance > 0.005) {
      const partnerName = getUserName(getPartnerUid());
      label.textContent = `${partnerName} owes you`;
      amount.textContent = `$${balance.toFixed(2)}`;
      amount.className = 'balance-amount positive';
    } else if (balance < -0.005) {
      const partnerName = getUserName(getPartnerUid());
      label.textContent = `You owe ${partnerName}`;
      amount.textContent = `$${Math.abs(balance).toFixed(2)}`;
      amount.className = 'balance-amount negative';
    } else {
      label.textContent = "You're all settled up!";
      amount.textContent = '$0.00';
      amount.className = 'balance-amount';
    }

    // Check for weekly duel availability
    const { isDuelAvailable } = await import('./duel.js');
    const duelBanner = document.getElementById('duel-banner');
    if (await isDuelAvailable()) {
      duelBanner.classList.remove('hidden');
    } else {
      duelBanner.classList.add('hidden');
    }

    // Load recent activity
    await loadRecentActivity();
  } catch (err) {
    console.error('Error loading dashboard:', err);
  }
}

async function loadRecentActivity() {
  const user = getCurrentUser();
  const list = document.getElementById('activity-list');
  list.innerHTML = '';

  // Fetch recent expenses and payments, merge and sort
  const [expSnap, paySnap, duelSnap] = await Promise.all([
    db.collection('expenses').orderBy('createdAt', 'desc').limit(10).get(),
    db.collection('payments').orderBy('createdAt', 'desc').limit(5).get(),
    db.collection('duels').orderBy('playedAt', 'desc').limit(3).get()
  ]);

  const items = [];
  expSnap.forEach((doc) => {
    const d = doc.data();
    items.push({ type: 'expense', date: d.date?.toDate?.() || new Date(d.date), ...d });
  });
  paySnap.forEach((doc) => {
    const d = doc.data();
    items.push({ type: 'payment', date: d.date?.toDate?.() || new Date(d.date), ...d });
  });
  duelSnap.forEach((doc) => {
    const d = doc.data();
    items.push({ type: 'duel', date: d.playedAt?.toDate?.() || new Date(), ...d });
  });

  items.sort((a, b) => b.date - a.date);
  items.slice(0, 10).forEach((item) => {
    const li = document.createElement('li');
    if (item.type === 'expense') {
      const isCredit = item.paidBy === user.uid;
      li.innerHTML = `
        <span class="entry-type expense">Expense</span>
        <div class="entry-info">
          <div class="entry-desc">${item.description}</div>
          <div class="entry-meta">${item.amount} ${item.currency} · ${item.splitType}</div>
        </div>
        <div class="entry-amount ${isCredit ? 'credit' : 'debit'}">
          ${isCredit ? '+' : '-'}$${(item.splitType === 'even' ? item.usdAmount / 2 : item.usdAmount).toFixed(2)}
        </div>`;
    } else if (item.type === 'payment') {
      const isCredit = item.paidBy === user.uid;
      li.innerHTML = `
        <span class="entry-type payment">Payment</span>
        <div class="entry-info">
          <div class="entry-desc">Settlement</div>
          <div class="entry-meta">${item.amount} ${item.currency}</div>
        </div>
        <div class="entry-amount ${isCredit ? 'credit' : 'debit'}">
          ${isCredit ? '+' : '-'}$${item.usdAmount.toFixed(2)}
        </div>`;
    } else if (item.type === 'duel') {
      const won = item.favoredUser === user.uid;
      li.innerHTML = `
        <span class="entry-type duel">Duel</span>
        <div class="entry-info">
          <div class="entry-desc">${item.game}</div>
          <div class="entry-meta">Week ${item.week}</div>
        </div>
        <div class="entry-amount ${won ? 'credit' : 'debit'}">
          ${won ? '+' : '-'}$${item.balanceAdjust.toFixed(2)}
        </div>`;
    }
    list.appendChild(li);
  });

  if (items.length === 0) {
    list.innerHTML = '<li style="justify-content:center;color:var(--text-muted)">No activity yet</li>';
  }
}

async function showApp() {
  document.getElementById('bottom-nav').classList.remove('hidden');
  const today = new Date().toISOString().split('T')[0];
  document.getElementById('expense-date').value = today;
  document.getElementById('payment-date').value = today;
  showScreen('dashboard');
  const { loadDashboard } = await import('./balance.js');
  loadDashboard();
}

import './expenses.js';
import './payments.js';

document.querySelectorAll('.nav-btn').forEach((btn) => {
  btn.addEventListener('click', async () => {
    showScreen(btn.dataset.screen);
    if (btn.dataset.screen === 'dashboard') {
      const { loadDashboard } = await import('./balance.js');
      loadDashboard();
    }
    if (btn.dataset.screen === 'history') {
      const { loadHistory } = await import('./history.js');
      loadHistory();
    }
  });
});

import { db } from './firebase-config.js';
import { getCurrentUser } from './app.js';

export async function loadHistory() {
  const user = getCurrentUser();
  const list = document.getElementById('history-list');
  list.innerHTML = '<li style="justify-content:center;color:var(--text-muted)">Loading...</li>';

  try {
    const [expSnap, paySnap, duelSnap] = await Promise.all([
      db.collection('expenses').orderBy('date', 'desc').get(),
      db.collection('payments').orderBy('date', 'desc').get(),
      db.collection('duels').orderBy('playedAt', 'desc').get()
    ]);

    const items = [];
    expSnap.forEach((doc) => {
      const d = doc.data();
      items.push({
        type: 'expense',
        date: d.date?.toDate?.() || new Date(d.date),
        ...d
      });
    });
    paySnap.forEach((doc) => {
      const d = doc.data();
      items.push({
        type: 'payment',
        date: d.date?.toDate?.() || new Date(d.date),
        ...d
      });
    });
    duelSnap.forEach((doc) => {
      const d = doc.data();
      items.push({
        type: 'duel',
        date: d.playedAt?.toDate?.() || new Date(),
        ...d
      });
    });

    items.sort((a, b) => b.date - a.date);
    list.innerHTML = '';

    if (items.length === 0) {
      list.innerHTML = '<li style="justify-content:center;color:var(--text-muted)">No history yet</li>';
      return;
    }

    items.forEach((item) => {
      const li = document.createElement('li');
      const dateStr = item.date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });

      if (item.type === 'expense') {
        const isCredit = item.paidBy === user.uid;
        const effectiveAmount = item.splitType === 'even' ? item.usdAmount / 2 : item.usdAmount;
        li.innerHTML = `
          <span class="entry-type expense">Expense</span>
          <div class="entry-info">
            <div class="entry-desc">${item.description}</div>
            <div class="entry-meta">${dateStr} · ${item.amount} ${item.currency} · ${item.splitType}</div>
          </div>
          <div class="entry-amount ${isCredit ? 'credit' : 'debit'}">
            ${isCredit ? '+' : '-'}$${effectiveAmount.toFixed(2)}
          </div>`;
      } else if (item.type === 'payment') {
        const isCredit = item.paidBy === user.uid;
        li.innerHTML = `
          <span class="entry-type payment">Payment</span>
          <div class="entry-info">
            <div class="entry-desc">Settlement</div>
            <div class="entry-meta">${dateStr} · ${item.amount} ${item.currency}</div>
          </div>
          <div class="entry-amount ${isCredit ? 'credit' : 'debit'}">
            ${isCredit ? '+' : '-'}$${item.usdAmount.toFixed(2)}
          </div>`;
      } else if (item.type === 'duel') {
        const won = item.favoredUser === user.uid;
        li.innerHTML = `
          <span class="entry-type duel">Duel</span>
          <div class="entry-info">
            <div class="entry-desc">${item.game}</div>
            <div class="entry-meta">${dateStr} · Week ${item.week}</div>
          </div>
          <div class="entry-amount ${won ? 'credit' : 'debit'}">
            ${won ? '+' : '-'}$${item.balanceAdjust.toFixed(2)}
          </div>`;
      }
      list.appendChild(li);
    });
  } catch (err) {
    console.error('Error loading history:', err);
    list.innerHTML = '<li style="justify-content:center;color:var(--text-muted)">Error loading history</li>';
  }
}

import { db } from './firebase-config.js';
import { getCurrentUser, showScreen } from './app.js';

const GAMES = ['coin-flip', 'wheel', 'rps', 'lucky-number', 'scratch-card'];
const GAME_NAMES = {
  'coin-flip': 'Coin Flip',
  'wheel': 'Wheel of Fortune',
  'rps': 'Rock Paper Scissors',
  'lucky-number': 'Lucky Number',
  'scratch-card': 'Scratch Card'
};

/**
 * Simple seeded PRNG (mulberry32).
 * Returns a function that produces deterministic floats in [0, 1).
 */
function seededRandom(seed) {
  return function() {
    seed |= 0;
    seed = seed + 0x6D2B79F5 | 0;
    let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
  };
}

/** Get ISO week number for a date. */
function getISOWeek(date) {
  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
  const dayNum = d.getUTCDay() || 7;
  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
  return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
}

/** Get the current week's seed, year, and week number. */
function getCurrentWeekInfo() {
  const now = new Date();
  const week = getISOWeek(now);
  const year = now.getFullYear();
  const seed = year * 100 + week;
  return { year, week, seed };
}

/**
 * Select this week's game deterministically from the seed.
 * Picks 3 candidates, then selects 1.
 */
export function getWeeklyGame(seed) {
  const rng = seededRandom(seed);
  // Shuffle and pick 3
  const shuffled = [...GAMES];
  for (let i = shuffled.length - 1; i > 0; i--) {
    const j = Math.floor(rng() * (i + 1));
    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
  }
  const candidates = shuffled.slice(0, 3);
  // Pick 1 from the 3
  const picked = candidates[Math.floor(rng() * 3)];
  return picked;
}

/** Check if a duel has been played this week. */
export async function isDuelAvailable() {
  const { year, week } = getCurrentWeekInfo();
  const snapshot = await db.collection('duels')
    .where('year', '==', year)
    .where('week', '==', week)
    .get();
  return snapshot.empty;
}

/** Start the weekly duel. */
export async function startDuel() {
  const available = await isDuelAvailable();
  if (!available) {
    alert('Duel already played this week!');
    return;
  }

  const { year, week, seed } = getCurrentWeekInfo();
  const game = getWeeklyGame(seed);

  showScreen('duel');
  const content = document.getElementById('duel-content');
  content.innerHTML = `
    <div class="duel-game">
      <h2>Weekly Duel</h2>
      <p class="subtitle">Week ${week} · ${GAME_NAMES[game]}</p>
      <div id="game-area"></div>
    </div>`;

  // Dynamically load the game module
  const gameModule = await import(`./games/${game}.js`);
  gameModule.play(document.getElementById('game-area'), { year, week, seed });
}

/**
 * Record duel result to Firestore.
 * Called by individual game modules when the game completes.
 */
export async function recordDuelResult({ game, result, balanceAdjust, favoredUser, seed, year, week }) {
  await db.collection('duels').add({
    year,
    week,
    game: GAME_NAMES[game] || game,
    result,
    balanceAdjust: Math.abs(balanceAdjust),
    favoredUser,
    playedAt: firebase.firestore.FieldValue.serverTimestamp(),
    seed,
    submissions: null
  });
}

// Wire up the duel banner button
document.getElementById('btn-play-duel').addEventListener('click', startDuel);

export { GAME_NAMES, getCurrentWeekInfo, seededRandom };

import './duel.js';

import('./js/duel.js').then(m => {
  console.log('This week:', m.getWeeklyGame(202613));
  console.log('Same seed again:', m.getWeeklyGame(202613));
  console.log('Different week:', m.getWeeklyGame(202614));
});

import { getCurrentUser, getPartnerUid } from '../app.js';
import { recordDuelResult } from '../duel.js';
import { computeBalance } from '../balance.js';

export async function play(container, { year, week, seed }) {
  const user = getCurrentUser();
  const balance = await computeBalance();
  // Debtor is the person who owes; if balance > 0, partner is debtor; if < 0, user is debtor
  const userIsDebtor = balance < 0;
  const debtorName = userIsDebtor ? 'You' : 'Partner';

  container.innerHTML = `
    <p>${debtorName} flip${userIsDebtor ? '' : 's'} the coin.</p>
    <p style="margin-top:8px;color:var(--text-muted)">Heads: $10 forgiven. Tails: $10 added.</p>
    <div class="coin" id="coin">?</div>
    <button class="btn btn-primary" id="btn-flip" style="max-width:200px;margin:0 auto">Flip!</button>
    <div id="flip-result"></div>`;

  document.getElementById('btn-flip').addEventListener('click', async () => {
    const btn = document.getElementById('btn-flip');
    btn.disabled = true;
    const coinEl = document.getElementById('coin');

    // Random result
    const isHeads = Math.random() < 0.5;
    coinEl.classList.add('flipping');
    coinEl.textContent = '';

    setTimeout(async () => {
      coinEl.classList.remove('flipping');
      coinEl.textContent = isHeads ? 'H' : 'T';

      const resultEl = document.getElementById('flip-result');
      // If heads, debtor gets $10 forgiven (favored). If tails, $10 added to their debt.
      // favoredUser: heads → debtor (their debt decreases), tails → creditor (debt increases)
      const debtorUid = userIsDebtor ? user.uid : getPartnerUid();
      const creditorUid = userIsDebtor ? getPartnerUid() : user.uid;
      const favoredUser = isHeads ? debtorUid : creditorUid;

      if (isHeads) {
        resultEl.innerHTML = `<div class="duel-result" style="color:var(--green)">Heads! $10 forgiven!</div>`;
      } else {
        resultEl.innerHTML = `<div class="duel-result" style="color:var(--red)">Tails! $10 added to debt.</div>`;
      }

      await recordDuelResult({
        game: 'coin-flip',
        result: { side: isHeads ? 'heads' : 'tails' },
        balanceAdjust: 10,
        favoredUser,
        seed, year, week
      });

      btn.textContent = 'Done!';
    }, 1000);
  });
}

import('./js/games/coin-flip.js').then(m => m.play(document.getElementById('game-area'), {year:2026, week:13, seed:202613}));

import { getCurrentUser, getPartnerUid } from '../app.js';
import { recordDuelResult } from '../duel.js';
import { computeBalance } from '../balance.js';

const SLICES = [
  { value: -10, label: '-$10', color: '#e94560' },
  { value: -5, label: '-$5', color: '#c73e54' },
  { value: 0, label: '$0', color: '#16213e' },
  { value: 0, label: '$0', color: '#0f3460' },
  { value: 5, label: '+$5', color: '#3a8a6a' },
  { value: 10, label: '+$10', color: '#4ecca3' }
];

export async function play(container, { year, week, seed }) {
  const user = getCurrentUser();
  const balance = await computeBalance();
  const userIsDebtor = balance < 0;

  // Draw the wheel using canvas
  container.innerHTML = `
    <p>Values are from the debtor's perspective.</p>
    <div class="wheel-container">
      <div class="wheel-pointer"></div>
      <canvas id="wheel-canvas" width="280" height="280"></canvas>
    </div>
    <button class="btn btn-primary" id="btn-spin" style="max-width:200px;margin:0 auto">Spin!</button>
    <div id="spin-result"></div>`;

  const canvas = document.getElementById('wheel-canvas');
  const ctx = canvas.getContext('2d');
  let currentAngle = 0;

  function drawWheel(angle) {
    ctx.clearRect(0, 0, 280, 280);
    const cx = 140, cy = 140, r = 130;
    const sliceAngle = (2 * Math.PI) / SLICES.length;

    SLICES.forEach((slice, i) => {
      const start = angle + i * sliceAngle;
      const end = start + sliceAngle;
      ctx.beginPath();
      ctx.moveTo(cx, cy);
      ctx.arc(cx, cy, r, start, end);
      ctx.closePath();
      ctx.fillStyle = slice.color;
      ctx.fill();
      ctx.strokeStyle = '#1a1a2e';
      ctx.lineWidth = 2;
      ctx.stroke();

      // Label
      ctx.save();
      ctx.translate(cx, cy);
      ctx.rotate(start + sliceAngle / 2);
      ctx.textAlign = 'center';
      ctx.fillStyle = '#eee';
      ctx.font = 'bold 16px sans-serif';
      ctx.fillText(slice.label, r * 0.65, 5);
      ctx.restore();
    });
  }

  drawWheel(0);

  document.getElementById('btn-spin').addEventListener('click', async () => {
    const btn = document.getElementById('btn-spin');
    btn.disabled = true;

    // Determine result
    const resultIndex = Math.floor(Math.random() * SLICES.length);
    const resultSlice = SLICES[resultIndex];

    // Calculate target angle: spin several full rotations + land on the slice
    // The pointer is at top (angle 0). Slice i occupies from i*60deg to (i+1)*60deg.
    // To land pointer on slice `resultIndex`, we need the center of that slice at angle 0 (top).
    const sliceAngle = (2 * Math.PI) / SLICES.length;
    const targetSliceCenter = resultIndex * sliceAngle + sliceAngle / 2;
    // Wheel rotates clockwise, pointer is fixed at top
    const spins = 5 + Math.random() * 3; // 5-8 full spins
    const totalAngle = spins * 2 * Math.PI + (2 * Math.PI - targetSliceCenter);

    // Animate
    const duration = 3000;
    const start = performance.now();
    const startAngle = currentAngle;

    function animate(now) {
      const elapsed = now - start;
      const progress = Math.min(elapsed / duration, 1);
      // Ease out cubic
      const eased = 1 - Math.pow(1 - progress, 3);
      currentAngle = startAngle + totalAngle * eased;
      drawWheel(-currentAngle); // negative because we rotate the wheel opposite to pointer

      if (progress < 1) {
        requestAnimationFrame(animate);
      } else {
        // Show result
        const resultEl = document.getElementById('spin-result');
        const debtorUid = userIsDebtor ? user.uid : getPartnerUid();
        const creditorUid = userIsDebtor ? getPartnerUid() : user.uid;

        let favoredUser = null;
        if (resultSlice.value > 0) {
          favoredUser = debtorUid; // debt reduced
        } else if (resultSlice.value < 0) {
          favoredUser = creditorUid; // debt increased
        }

        if (resultSlice.value > 0) {
          resultEl.innerHTML = `<div class="duel-result" style="color:var(--green)">${resultSlice.label} — debt reduced!</div>`;
        } else if (resultSlice.value < 0) {
          resultEl.innerHTML = `<div class="duel-result" style="color:var(--red)">${resultSlice.label} — debt increased!</div>`;
        } else {
          resultEl.innerHTML = `<div class="duel-result">$0 — no change!</div>`;
        }

        recordDuelResult({
          game: 'wheel',
          result: { value: resultSlice.value },
          balanceAdjust: Math.abs(resultSlice.value),
          favoredUser,
          seed, year, week
        });

        btn.textContent = 'Done!';
      }
    }

    requestAnimationFrame(animate);
  });
}