import { db } from './index';
import type { GameState, Encounter, EncounterType } from './schema';

// Initialize or get game state
export async function getOrCreateGameState(): Promise<GameState> {
  const states = await db.gameState.toArray();
  
  if (states.length > 0) {
    // Update last played
    await db.gameState.update(states[0].id!, { lastPlayed: new Date() });
    return states[0];
  }
  
  // Create initial game state
  const newState: Omit<GameState, 'id'> = {
    lastEncounterRefresh: new Date(),
    lastPlayed: new Date(),
    progressPoints: 0,
    trainersDefeated: 0,
    picletsCapured: 0,
    battlesLost: 0
  };
  
  const id = await db.gameState.add(newState);
  return { ...newState, id };
}

// Update progress
export async function updateProgress(updates: Partial<GameState>): Promise<void> {
  const state = await getOrCreateGameState();
  await db.gameState.update(state.id!, updates);
}

// Increment specific counters
export async function incrementCounter(counter: 'trainersDefeated' | 'picletsCapured' | 'battlesLost'): Promise<void> {
  const state = await getOrCreateGameState();
  await db.gameState.update(state.id!, {
    [counter]: state[counter] + 1
  });
}

// Add progress points
export async function addProgressPoints(points: number): Promise<void> {
  const state = await getOrCreateGameState();
  const newPoints = Math.min(1000, state.progressPoints + points);
  await db.gameState.update(state.id!, {
    progressPoints: newPoints
  });
}

// Create a new encounter
export async function createEncounter(encounter: Omit<Encounter, 'id' | 'createdAt'>): Promise<number> {
  return await db.encounters.add({
    ...encounter,
    createdAt: new Date()
  });
}

// Get recent encounters
export async function getRecentEncounters(limit: number = 10): Promise<Encounter[]> {
  return await db.encounters
    .orderBy('createdAt')
    .reverse()
    .limit(limit)
    .toArray();
}

// Get encounters by type
export async function getEncountersByType(type: EncounterType): Promise<Encounter[]> {
  return await db.encounters
    .where('type')
    .equals(type)
    .toArray();
}

// Check if should refresh encounters (e.g., every hour)
export async function shouldRefreshEncounters(): Promise<boolean> {
  const state = await getOrCreateGameState();
  const hoursSinceRefresh = (Date.now() - state.lastEncounterRefresh.getTime()) / (1000 * 60 * 60);
  return hoursSinceRefresh >= 1;
}

// Mark encounters as refreshed
export async function markEncountersRefreshed(): Promise<void> {
  const state = await getOrCreateGameState();
  await db.gameState.update(state.id!, {
    lastEncounterRefresh: new Date()
  });
}