import { db } from './index';
import type { PicletInstance, Monster, BattleMove } from './schema';

// Convert a generated Monster to a PicletInstance
export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
  if (!monster.stats) {
    throw new Error('Monster must have stats to create PicletInstance');
  }

  const stats = monster.stats;
  
  // Calculate base stats from the 0-100 scale
  const baseHp = Math.floor(stats.HP * 2 + 50);
  const baseAttack = Math.floor(stats.attack * 1.5 + 30);
  const baseDefense = Math.floor(stats.defence * 1.5 + 30);
  const baseSpeed = Math.floor(stats.speed * 1.5 + 30);
  
  // Field stats are variations of regular stats
  const baseFieldAttack = Math.floor(baseAttack * 0.8);
  const baseFieldDefense = Math.floor(baseDefense * 0.8);
  
  // Calculate current stats based on level
  const calculateStat = (base: number, level: number) => Math.floor((base * level) / 50 + 5);
  const calculateHp = (base: number, level: number) => Math.floor((base * level) / 50 + level + 10);
  
  const maxHp = calculateHp(baseHp, level);
  
  // Create moves based on monster's abilities
  const moves: BattleMove[] = [
    {
      name: stats.attackActionName,
      type: 'normal',
      power: 50,
      accuracy: 95,
      pp: 20,
      currentPp: 20,
      description: stats.attackActionDescription
    },
    {
      name: stats.buffActionName,
      type: 'status',
      power: 0,
      accuracy: 100,
      pp: 15,
      currentPp: 15,
      description: stats.buffActionDescription
    },
    {
      name: stats.debuffActionName,
      type: 'status',
      power: 0,
      accuracy: 85,
      pp: 15,
      currentPp: 15,
      description: stats.debuffActionDescription
    },
    {
      name: stats.specialActionName,
      type: 'special',
      power: 80,
      accuracy: 90,
      pp: 5,
      currentPp: 5,
      description: stats.specialActionDescription
    }
  ];
  
  const bst = baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed;
  
  return {
    // Type Info
    typeId: monster.name.toLowerCase().replace(/\s+/g, '-'),
    nickname: monster.name,
    primaryTypeString: 'normal', // Default type, could be enhanced based on concept
    secondaryTypeString: undefined,
    
    // Current Stats
    currentHp: maxHp,
    maxHp,
    level,
    xp: 0,
    attack: calculateStat(baseAttack, level),
    defense: calculateStat(baseDefense, level),
    fieldAttack: calculateStat(baseFieldAttack, level),
    fieldDefense: calculateStat(baseFieldDefense, level),
    speed: calculateStat(baseSpeed, level),
    
    // Base Stats
    baseHp,
    baseAttack,
    baseDefense,
    baseFieldAttack,
    baseFieldDefense,
    baseSpeed,
    
    // Battle
    moves,
    nature: 'hardy', // Default nature
    
    // Roster
    isInRoster: false,
    rosterPosition: undefined,
    
    // Metadata
    caughtAt: new Date(),
    bst,
    tier: stats.rarity > 80 ? 'legendary' : stats.rarity > 60 ? 'rare' : stats.rarity > 40 ? 'uncommon' : 'common',
    role: 'balanced', // Could be enhanced based on stat distribution
    variance: 0,
    
    // Original generation data
    imageUrl: monster.imageUrl,
    imageData: monster.imageData,
    imageCaption: monster.imageCaption,
    concept: monster.concept,
    imagePrompt: monster.imagePrompt
  };
}

// Save a new PicletInstance
export async function savePicletInstance(piclet: Omit<PicletInstance, 'id'>): Promise<number> {
  return await db.picletInstances.add(piclet);
}

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

// Get roster PicletInstances
export async function getRosterPiclets(): Promise<PicletInstance[]> {
  return await db.picletInstances
    .where('isInRoster')
    .equals(1)
    .sortBy('rosterPosition');
}

// Update roster position
export async function updateRosterPosition(id: number, position: number | undefined): Promise<void> {
  await db.picletInstances.update(id, {
    isInRoster: position !== undefined,
    rosterPosition: position
  });
}

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