import { RPGEventGenerator, generateRPGEvent } from 'rpg-event-generator';

// Quick single event
const event = generateRPGEvent({
  age: 25,
  gold: 500,
  influence: 15,
  career: 'merchant'
});

console.log(event.title); // "Golden Opportunity"
console.log(event.description); // Procedurally generated description
console.log(event.choices); // Array of choices with effects

// Advanced usage with custom generator
const generator = new RPGEventGenerator({
  stateSize: 2,
  trainingData: ['Your custom story fragments...']
});

// Generate multiple events
const events = generator.generateEvents({
  age: 30,
  gold: 1000,
  influence: 25,
  career: 'knight',
  skills: { combat: 60, diplomacy: 40 }
}, 3);

const generator = new RPGEventGenerator();

// Generate a random event
const event = generator.generateEvent();

console.log(event);
// {
//   id: "event_1704567890123_xyz789",
//   title: "Perilous Bandit King's Challenge",
//   description: "The infamous bandit king blocks your path, offering you a choice: join his band or face certain death. Your business interests are directly affected by this development. Choose wisely, for the wrong path leads to ruin.",
//   narrative: "The infamous bandit king blocks your path, offering you a choice: join his band or face certain death.",
//   choices: [
//     {
//       text: "Join the bandits",
//       effect: { gold: 375, reputation: -23, combat_skill: 12 },
//       consequence: "bandit"
//     },
//     {
//       text: "Challenge him to single combat",
//       effect: { reputation: 32, health: -18 },
//       requirements: { combat_skill: 60 },
//       consequence: "hero"
//     },
//     {
//       text: "Bribe your way past",
//       effect: { gold: -320, safe_passage: true },
//       consequence: "diplomat"
//     }
//   ],
//   type: "BANDIT_KING",
//   consequence: null,
//   urgency: "normal",
//   theme: "adventure",
//   context: { /* player context used */ }
// }

const playerContext = {
  age: 35,
  gold: 2500,
  influence: 40,
  reputation: 25,
  career: 'noble',
  skills: {
    diplomacy: 70,
    combat: 45,
    intrigue: 30
  },
  relationships: [
    { name: 'Lord Harrington', type: 'ally', relationship: 60 },
    { name: 'Lady Beaumont', type: 'lover', relationship: 45 }
  ],
  location: 'capital',
  season: 'winter'
};

const event = generator.generateEvent(playerContext);
// Generates events like:
// - Diplomatic missions (high diplomacy skill)
// - Court intrigue opportunities (high influence)
// - Social events involving relationships
// - Winter-themed challenges

const customTrainingData = [
  'In the shadowed alleys of the ancient city',
  'The dragon\'s roar echoes through the mountains',
  'Elven merchants display their enchanted wares',
  'A dwarven smith forges weapons of legend',
  'The tavern is filled with adventurers and mercenaries',
  'Ancient runes glow with mystical power',
  'The forest whispers secrets to those who listen'
];

const generator = new RPGEventGenerator({
  trainingData: customTrainingData
});

const generator = new RPGEventGenerator({
  stateSize: 2,        // Markov chain state size (default: 2)
  trainingData: [...]  // Custom training data array (optional)
});

{
  age: number,              // Player age
  gold: number,             // Player wealth
  influence: number,        // Political/social influence
  reputation: number,       // Social reputation
  career: string,           // Player's career/job
  skills: {                 // Skill levels object
    combat: number,
    diplomacy: number,
    // ... other skills
  },
  relationships: [{         // Array of relationships
    name: string,
    type: string,          // 'friend', 'lover', 'ally', etc.
    relationship: number   // Relationship strength (0-100)
  }],
  location: string,         // Current location
  season: string           // Current season
}

{
  id: string,              // Unique event identifier
  title: string,           // Dynamic, context-aware title
  description: string,     // Rich procedural description
  narrative: string,       // Core story premise
  choices: [{              // Array of meaningful choices
    text: string,          // Choice text with contextual flavor
    effect: {              // Effects scaled by context
      gold?: number,        // Wealth changes
      influence?: number,   // Social/political power
      reputation?: number,  // Social standing
      health?: number,      // Physical well-being
      stress?: number,      // Mental strain
      karma?: number,       // Moral standing
      // ... many more effects
    },
    consequence: string    // Long-term character effect
  }],
  type: string,           // Rich event category (COURT_SCANDAL, etc.)
  consequence: string|null, // Applied consequence after choice
  urgency: string,        // 'normal', 'high', 'critical'
  theme: string,          // 'political', 'criminal', 'supernatural', etc.
  context: object         // Full context used for generation
}

import React, { useState, useEffect } from 'react';
import { RPGEventGenerator } from 'rpg-event-generator';

function GameEventSystem({ playerStats }) {
  const [currentEvent, setCurrentEvent] = useState(null);
  const [generator] = useState(() => new RPGEventGenerator());

  useEffect(() => {
    // Generate event when time advances
    const event = generator.generateEvent(playerStats);
    setCurrentEvent(event);
  }, [playerStats, generator]);

  const handleChoice = (choiceIndex) => {
    const choice = currentEvent.choices[choiceIndex];
    // Apply effects to player stats
    applyEffects(choice.effect);
    setCurrentEvent(null); // Clear event
  };

  if (!currentEvent) return null;

  return (
    <EventDialog
      event={currentEvent}
      onChoice={handleChoice}
    />
  );
}

// Action creators
export const generateEvent = (playerContext) => {
  const generator = new RPGEventGenerator();
  const event = generator.generateEvent(playerContext);

  return {
    type: 'GENERATE_EVENT',
    payload: event
  };
};

export const resolveEvent = (eventId, choiceIndex) => ({
  type: 'RESOLVE_EVENT',
  payload: { eventId, choiceIndex }
});

// Reducer
const eventReducer = (state = {}, action) => {
  switch (action.type) {
    case 'GENERATE_EVENT':
      return { ...state, currentEvent: action.payload };
    case 'RESOLVE_EVENT':
      return { ...state, currentEvent: null };
    default:
      return state;
  }
};

const customTemplates = {
  QUEST: {
    title: 'Epic Quest',
    choices: [
      { text: 'Accept the quest', effect: { influence: [20, 40] } },
      { text: 'Decline politely', effect: {} }
    ]
  }
};

// Extend the generator
class CustomRPGEventGenerator extends RPGEventGenerator {
  constructor(options) {
    super(options);
    this.templates = { ...this.templates, ...customTemplates };
  }
}

// Add custom effects
const event = generator.generateEvent(playerContext);

// Custom effect resolution
function resolveCustomEffects(choice, playerContext) {
  const effects = resolveEffect(choice.effect, playerContext);

  // Add custom logic
  if (effects.experience) {
    // Handle experience gain
  }

  if (effects.relationshipChange) {
    // Update relationship values
  }

  return effects;
}