import { db } from './index';
import type { PicletInstance } from './schema';
import { PicletType } from '../types/picletTypes';
import type { PicletStats } from '../types';

// Interface for generated piclet data (from PicletResult component)
interface GeneratedPicletData {
  name: string;
  imageUrl: string;
  imageData?: string;
  imageCaption: string;
  concept: string;
  imagePrompt: string;
  stats: PicletStats;
  createdAt: Date;
}

// Convert generated piclet data to a PicletInstance
export async function generatedDataToPicletInstance(data: GeneratedPicletData): Promise<Omit<PicletInstance, 'id'>> {
  if (!data.stats) {
    throw new Error('Generated data must have stats to create PicletInstance');
  }

  const stats = data.stats as PicletStats;
  
  // Map tier from stats
  let tier: string = stats.tier || 'medium';
  
  // Check if this is the first piclet (no existing piclets in database)
  const existingPiclets = await db.picletInstances.count();
  const isFirstPiclet = existingPiclets === 0;
  
  return {
    // Basic Info
    typeId: stats.name || data.name,
    nickname: stats.name || data.name,
    primaryType: stats.primaryType as PicletType,
    tier: tier,
    
    // Roster Management
    isInRoster: isFirstPiclet,
    rosterPosition: isFirstPiclet ? 0 : undefined,
    
    // Metadata
    caught: isFirstPiclet, // First piclet is automatically caught
    caughtAt: isFirstPiclet ? new Date() : undefined,
    
    // Original generation data
    imageUrl: data.imageUrl,
    imageData: data.imageData,
    imageCaption: data.imageCaption,
    concept: data.concept,
    description: stats.description,
    imagePrompt: data.imagePrompt
  };
}

// Save a piclet instance to the database
export async function savePicletInstance(picletInstance: Omit<PicletInstance, 'id'>): Promise<number> {
  const id = await db.picletInstances.add(picletInstance as any);
  return id;
}

// Update a piclet instance in the database
export async function updatePicletInstance(id: number, updates: Partial<PicletInstance>): Promise<void> {
  await db.picletInstances.update(id, updates);
}

// Delete a piclet instance from the database
export async function deletePicletInstance(id: number): Promise<void> {
  await db.picletInstances.delete(id);
}

// Get all piclet instances
export async function getAllPicletInstances(): Promise<PicletInstance[]> {
  return await db.picletInstances.toArray();
}

// Get a single piclet instance by ID
export async function getPicletInstance(id: number): Promise<PicletInstance | undefined> {
  return await db.picletInstances.get(id);
}

// Get roster piclets (those currently in battle roster)
export async function getRosterPiclets(): Promise<PicletInstance[]> {
  return await db.picletInstances.where('isInRoster').equals(1).toArray();
}

// Get caught piclets (those that have been captured)
export async function getCaughtPiclets(): Promise<PicletInstance[]> {
  return await db.picletInstances.where('caught').equals(1).toArray();
}

// Move a piclet to roster (simplified version)
export async function moveToRoster(picletId: number, position: number): Promise<void> {
  await db.picletInstances.update(picletId, {
    isInRoster: true,
    rosterPosition: position
  });
}

// Get uncaught piclets
export async function getUncaughtPiclets(): Promise<PicletInstance[]> {
  return await db.picletInstances.where('caught').equals(0).toArray();
}

// Swap roster positions (simplified version)
export async function swapRosterPositions(id1: number, position1: number, id2: number, position2: number): Promise<void> {
  await db.picletInstances.update(id1, { rosterPosition: position2 });
  await db.picletInstances.update(id2, { rosterPosition: position1 });
}

// Move to storage (simplified version)
export async function moveToStorage(picletId: number): Promise<void> {
  await db.picletInstances.update(picletId, {
    isInRoster: false,
    rosterPosition: undefined
  });
}