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

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

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

const EventEconomy = require('./scripts/event-economy');

// Initialize the system
const economy = new EventEconomy('./my-user-content');

// Save a custom theme
const themeData = {
  author: 'YourName',
  description: 'Cyberpunk western theme',
  tags: ['cyberpunk', 'western', 'scifi'],
  theme: 'cyberpunk',
  culture: 'western',
  trainingData: [
    'neon signs flicker in the dusty saloon',
    'robotic sheriffs patrol the asteroid streets',
    'cyborg outlaws ride mechanical horses'
  ],
  enableRuleEngine: true,
  customRules: [] // your custom rules here
};

const filepath = economy.saveTheme('CyberWestern', themeData);
console.log(`Theme saved to: ${filepath}); // ./my-user-content/themes/cyberwestern.json

// List available themes
const themes = economy.listThemes();
console.log('Available themes:', themes);

// Load and use a theme
const loadedTheme = economy.loadTheme('CyberWestern');
// Use with generator...

// Create a complete content pack
const packData = {
  author: 'ContentCreator',
  description: 'Complete cyberpunk western adventure pack',
  theme: themeData, // include your theme
  rulePacks: ['combat-rules', 'dialogue-rules'] // reference rule packs
};

const packPath = economy.createContentPack('CyberWesternAdventure', packData);

// Load theme and apply to generator
const theme = economy.loadTheme('CyberWestern');
const generator = new RPGEventGenerator({
  theme: theme.settings.theme,
  culture: theme.settings.culture,
  trainingData: theme.trainingData,
  customRules: theme.customRules,
  enableRuleEngine: theme.settings.enableRuleEngine
});

// Generate events with custom theme
const event = generator.generateEvent();

const generator = new RPGEventGenerator();
const event = generator.generateEvent();

console.log(event);
// {
//   id: "event_1704567890123_xyz789",
//   title: "Perilous Bandit King's Challenge",
//   description: "Generated narrative based on Markov chains...",
//   choices: [
//     { text: "Fight back", effect: { health: -20, reputation: 25 } },
//     { text: "Pay tribute", effect: { gold: -200, safe_passage: true } }
//   ],
//   type: "BANDIT_KING",
//   difficulty: "normal"
// }

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 }
  ],
  location: 'capital',
  season: 'winter'
};

const event = generator.generateEvent(playerContext);
// Generates events appropriate to noble career, high influence, winter season

const customTrainingData = [
  'In the shadowed alleys of the ancient city',
  'The dragon\'s roar echoes through the misty mountains',
  'Elven merchants display their enchanted crystal wares',
  'A dwarven smith forges weapons of legendary power',
  'The tavern overflows with adventurers and mysterious strangers',
  'Ancient runes glow with ethereal magical energy',
  'The enchanted forest whispers secrets to those who listen carefully'
];

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

// Events will now incorporate your custom story elements
const event = generator.generateEvent();
// May generate: "In the shadowed alleys of the ancient city, a mysterious stranger approaches..."

// Fantasy (default) - knights, magic, dragons
const fantasyGen = new RPGEventGenerator({ theme: 'fantasy' });

// Fantasy with Norse culture - vikings, runes, fjords
const norseGen = new RPGEventGenerator({
  theme: 'fantasy',
  culture: 'norse'
});
const norseEvent = norseGen.generateEvent();
// Generates: "The longships sail into the fjord under the northern lights..."

// Sci-fi - corporations, AI, space exploration
const sciFiGen = new RPGEventGenerator({ theme: 'sci-fi' });

// Cyberpunk sci-fi - neon cities, megacorps, hackers
const cyberpunkGen = new RPGEventGenerator({
  theme: 'sci-fi',
  culture: 'cyberpunk'
});
const cyberEvent = cyberpunkGen.generateEvent();
// Generates: "Neon lights reflect off rain-slicked streets in the megacity sprawl..."

// Historical - medieval politics, exploration, warfare
const historicalGen = new RPGEventGenerator({ theme: 'historical' });

// Victorian historical - industrial revolution, social reform
const victorianGen = new RPGEventGenerator({
  theme: 'historical',
  culture: 'victorian'
});
const victorianEvent = victorianGen.generateEvent();
// Generates: "Steam engines power the industrial revolution across soot-stained cities..."

// Start a multi-part storyline
const generator = new RPGEventGenerator();
const firstEvent = generator.startChain('BANDIT_RISING');

console.log(firstEvent.title); // "Treacherous Bandit Ambush"
console.log(firstEvent.chainId); // "chain_1704567890123_xyz789"

// Advance chain based on player choice
const nextEvent = generator.advanceChain(firstEvent.chainId, 'hero');
console.log(nextEvent.title); // "Perilous Bandit King's Challenge"

// Check active chains
const activeChains = generator.getActiveChains();
console.log(`Active chains: ${activeChains.length}`);

// Available built-in chains:
// - BANDIT_RISING: Highway robbery escalating to kingdom threat
// - COURT_SCANDAL_CHAIN: Royal intrigue with multiple betrayals
// - CURSE_OF_THE_ARTIFACT: Ancient curse with escalating effects
// - MERCHANT_EMPIRE: Trade empire building with setbacks

// Advance game time and handle due events
const dueEvents = generator.advanceGameDay();

dueEvents.forEach(event => {
  if (event.type === 'time_based_chain') {
    const chainData = generator.timeSystem.timeBasedEvents.get(event.chainId);
    const gameEvent = generator.generateChainEvent(chainData);
    // Add to your game's event system
  }
});

// Start evolving storylines
generator.startTimeBasedChain('POLITICAL_UPRISING');
// - Day 1: Whispers of dissent appear
// - Day 7: Public protests erupt
// - Day 14: Open rebellion begins
// - Day 21: Revolutionary climax

// Check current game time
const currentTime = generator.getCurrentTime();
console.log(`Day ${currentTime.day}, Season: ${currentTime.season}`);

const generator = new RPGEventGenerator({
  language: 'es',  // Spanish events
  theme: 'fantasy'
});

// Load additional language packs
generator.loadLanguagePack('fr', frenchTranslations);
generator.setLanguage('fr');

// Events now generate in French
const event = generator.generateEvent();
console.log(event.title); // "Embuscade de Brigands"

const generator = new RPGEventGenerator({ enableModifiers: true });

// Set environmental context
generator.setEnvironmentalContext({
  weather: 'storm',
  season: 'winter',
  timeOfDay: 'night'
});

// Events adapt to harsh winter storm conditions
const event = generator.generateEnhancedEvent({
  environment: { weather: 'storm', season: 'winter' }
});

// Register event dependencies
generator.registerEventDependency('ROYAL_WEDDING', {
  type: 'event_completed',
  eventId: 'COURT_INTRODUCTION'
});

generator.registerEventDependency('ADVANCED_QUEST', {
  operator: 'AND',
  conditions: [
    { type: 'stat_requirement', stat: 'level', min: 5 },
    { type: 'event_completed', eventId: 'BASIC_QUEST' }
  ]
});

// Only generate events whose dependencies are met
const gameState = { completedEvents: new Set(['COURT_INTRODUCTION']) };
const event = generator.generateEnhancedEvent({ gameState });

const generator = new RPGEventGenerator({ enableRelationships: true });

// Add NPCs to the relationship network
generator.addNPC({
  id: 'king_arthur',
  name: 'King Arthur',
  type: 'noble'
});

// Update relationships based on player actions
generator.applyRelationshipRule('king_arthur', 'player', 'save_life');
// Relationship with king improves significantly

generator.updateRelationship('merchant_john', 'player', -10, 'stole goods');
// Relationship with merchant deteriorates

// Generate events that consider relationship context
const event = generator.generateEnhancedEvent({
  player: { id: 'player' }
});

const generator = new RPGEventGenerator({
  enableTemplates: true,
  templateLibrary: 'fantasy'  // Load fantasy templates
});

// Generate from specific template
const dragonEvent = generator.generateFromTemplate('dragon_lair');
console.log(dragonEvent.title); // "Ancient Dragon's Lair"

// Generate random event from genre
const fantasyEvent = generator.generateFromGenre('fantasy');

// Discover available templates
const availableTemplates = generator.getAvailableTemplates();
console.log(Object.keys(availableTemplates)); // ['fantasy', 'sci-fi', etc.]

// Create a custom template
const myTemplate = {
  title: 'Space Station Malfunction',
  narrative: 'Critical system failure detected. Alarms blare throughout the station.',
  choices: [
    {
      text: 'Attempt emergency repair',
      effect: { risk: 30, engineering: 20 },
      consequence: 'repair_attempt'
    },
    {
      text: 'Abandon the station',
      effect: { survival: 10, resources: -50 },
      consequence: 'abandon_station'
    }
  ],
  type: 'TECHNICAL_CRISIS',
  difficulty: 'hard',
  tags: ['space', 'technology', 'emergency']
};

// Add to your game's template collection
// Templates can be saved as JSON files in custom directories

// Register custom event templates
const customTemplate = {
  title: 'Mystic Vision',
  narrative: 'You experience a vivid prophetic dream showing future events.',
  choices: [
    {
      text: 'Seek out the prophecy',
      effect: { wisdom: 15, risk: 20 },
      consequence: 'visionary'
    },
    {
      text: 'Dismiss it as a dream',
      effect: { stress: -10 },
      consequence: 'skeptical'
    }
  ]
};

generator.registerEventTemplate('MYSTIC_VISION', customTemplate);

// Add custom training data for better text generation
generator.addCustomTrainingData([
  'The ancient prophecy foretells of great change',
  'Mystic visions reveal hidden truths to the worthy',
  'Dreams of the future guide the destinies of heroes'
], 'mystical');

// Create custom event chains
const visionChain = {
  name: 'Prophetic Journey',
  description: 'A chain of events triggered by mystic visions',
  stages: [
    { day: 1, template: 'MYSTIC_VISION' },
    { day: 5, template: 'ANCIENT_RUINS' },
    { day: 10, template: 'FINAL_PROPHECY' }
  ]
};

generator.registerEventChain('PROPHECY_CHAIN', visionChain);

// Export/import custom content for sharing
const customContent = generator.exportCustomContent();
console.log('Exported:', Object.keys(customContent.templates).length, 'templates');

const newGenerator = new RPGEventGenerator();
const importResult = newGenerator.importCustomContent(customContent);
console.log('Imported:', importResult.templates.success, 'templates');

// Weak character (easy difficulty)
const weakling = {
  gold: 50,
  influence: 10,
  skills: { combat: 20 }
};
const easyEvent = generator.generateEvent(weakling);
console.log(`Difficulty: ${easyEvent.difficulty}`); // "easy"
// Effects scaled for beginners: higher rewards, lower penalties

// Powerful character (hard difficulty)
const hero = {
  gold: 50000,
  influence: 500,
  skills: { combat: 100, diplomacy: 80 },
  relationships: [{ name: 'King', type: 'ally', relationship: 80 }]
};
const hardEvent = generator.generateEvent(hero);
console.log(`Difficulty: ${hardEvent.difficulty}`); // "hard"
// Effects scaled for challenge: lower rewards, higher penalties

// Legendary character (legendary difficulty)
const godlike = {
  gold: 200000,
  influence: 1000,
  skills: { combat: 200, diplomacy: 150 },
  age: 120,
  reputation: 95
};
const epicEvent = generator.generateEvent(godlike);
console.log(`Difficulty: ${epicEvent.difficulty}`); // "legendary"
// Effects scaled for epic gameplay: minimal rewards, maximum penalties

const generator = new RPGEventGenerator({
  // Core options
  stateSize: 2,           // Markov chain state size (default: 2)
  trainingData: [...],     // Custom training data array
  theme: 'fantasy',        // 'fantasy', 'sci-fi', 'historical'
  culture: 'norse',        // Cultural variant within theme

  // Enhanced features (all enabled by default)
  enableDependencies: true,    // Complex event prerequisites
  enableModifiers: true,       // Weather/season/location modifiers
  enableRelationships: true,   // NPC relationship networks
  language: 'en'               // Default language for events
});

{
  age: number,                    // Player age
  gold: number,                   // Player wealth
  influence: number,              // Political/social influence
  reputation: number,             // Social reputation
  career: string,                 // Player's career/job ('noble', 'merchant', 'warrior', etc.)
  skills: {                       // Skill levels object
    combat: number,               // 0-100 scale
    diplomacy: number,
    intrigue: number,
    magic: number,
    survival: number
  },
  relationships: [{               // Array of NPC relationships
    name: string,                 // NPC name
    type: string,                 // 'friend', 'lover', 'ally', 'enemy', 'rival'
    relationship: number          // Relationship strength (0-100)
  }],
  location: string,               // Current location ('capital', 'village', 'forest', etc.)
  season: string                  // Current season ('spring', 'summer', 'autumn', 'winter')
}

{
  id: "event_1704567890123_xyz789",    // Unique event identifier
  title: "Perilous Bandit King's Challenge", // Dynamic, context-aware title
  description: "The infamous bandit king blocks your path, offering you a choice...", // Rich procedural description
  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,
  context: { /* Full context used for generation */ },
  urgency: "normal",
  theme: "adventure",
  difficulty: "normal"

}

const generator = new RPGEventGenerator({
  trainingData: [
    'Space cowboys patrol asteroid fields on mechanical horses',
    'Neon-lit cantinas echo with the hum of quantum pianos',
    'Laser revolvers fire streams of pure starlight',
    'Alien saloons serve drinks that change your memories',
    'Robotic sheriffs maintain order in floating colonies'
  ],
  theme: 'sci-fi',
  culture: 'western'
});

// Events will incorporate your custom atmosphere
const event = generator.generateEvent({
  career: 'gunslinger',
  location: 'asteroid-town'
});

const pureGenerator = new RPGEventGenerator({
  trainingData: [
    'Crystal caves echo with ancient magic',
    'Shadowy figures move through fog-shrouded forests',
    'Forgotten ruins hide treasures and traps',
    'Mysterious merchants offer enchanted artifacts',
    'Wandering bards sing tales of lost kingdoms'
  ],
  pureMarkovMode: true,  // No templates used
  enableTemplates: false
});

// Generates events purely from your text
const event = pureGenerator.generateEvent();
// Type: "MARKOV_GENERATED"
// Title: "Crystal caves echo with ancient magic."
// Description: Generated purely from your atmospheric training sentences

const generator = new RPGEventGenerator({
  enableRuleEngine: true
});

// Add a wealthy player bonus
generator.addCustomRule('wealthy_bonus', {
  conditions: [
    { type: 'stat_greater_than', params: { stat: 'gold', value: 1000 } }
  ],
  effects: {
    addTags: ['wealthy_player'],
    modifyChoices: {
      multiply: { gold: 1.3 },  // 30% more gold rewards
      add: { reputation: 5 }    // Bonus reputation
    }
  }
});

// Events for wealthy players get enhanced
const wealthyEvent = generator.generateEvent({ gold: 2000 });
console.log(wealthyEvent.tags); // Includes 'wealthy_player'

// Complex conditional logic
generator.addCustomRule('noble_intrigue', {
  conditions: [
    { type: 'and', params: {
      conditions: [
        { type: 'career_is', params: { career: 'noble' } },
        { type: 'location_is', params: { location: 'castle' } },
        { type: 'stat_greater_than', params: { stat: 'influence', value: 50 } }
      ]
    }}
  ],
  effects: {
    modifyTitle: { append: ' (Royal Privilege)' },
    setDifficulty: 'hard',
    addTags: ['noble_bonus', 'court_influence']
  }
});

// Available condition types:
// - stat_greater_than, stat_less_than, stat_between
// - location_is, season_is, career_is, time_greater_than
// - has_item, relationship_status
// - random_chance
// - and, or, not (for combining conditions)

// Validate rules before adding
const rule = { /* your rule */ };
const validation = generator.validateCustomRule(rule);
if (validation.valid) {
  generator.addCustomRule('my_rule', rule);
} else {
  console.log('Rule errors:', validation.errors);
}

// Manage rules
console.log(generator.getCustomRules());  // View all rules
generator.removeCustomRule('my_rule');    // Remove specific rule
generator.clearCustomRules();             // Remove all rules

// Programmatic export
const exporter = require('./scripts/export-templates.js');
exporter.exportTemplates('unity', 'fantasy');

// Creates: templates/unity/fantasy/event_1.cs
// Result: Event1.cs - Unity ScriptableObject

// Export for Godot
const exporter = require('./scripts/export-templates.js');
exporter.exportTemplates('godot', 'cyberpunk');

// Creates: templates/godot/cyberpunk/event_1.gd
// Result: Event1.gd - Godot Resource script

// Export as TypeScript interfaces
const exporter = require('./scripts/export-templates.js');
exporter.exportTemplates('typescript', 'space-opera');

// Creates: templates/typescript/space-opera/event_1.ts
// Result: Strongly-typed event definitions

// Load genre-specific templates
const fantasyGen = new RPGEventGenerator({
  enableTemplates: true,
  templateLibrary: 'fantasy'
});

// Generate from specific genre
const fantasyEvent = fantasyGen.generateFromGenre('fantasy');
const horrorEvent = fantasyGen.generateFromTemplate('haunted_mansion');

// Available templates
console.log(fantasyGen.getAvailableTemplates());
// { fantasy: [...], sci-fi: [...], horror: [...], etc. }

const generator = new RPGEventGenerator({
  // v1.x options still supported
  theme: 'fantasy',
  culture: 'norse',
  trainingData: [...],
  enableModifiers: true,

  // v2.0.0 new options
  enableRuleEngine: true,     // Enable custom rules system
  customRules: {},           // Pre-load custom rules
  pureMarkovMode: false,     // Generate purely from training data
  templateLibrary: null      // Load specific template genre
});

// Rule Engine
generator.addCustomRule(name, ruleDefinition);
generator.removeCustomRule(name);
generator.getCustomRules();
generator.clearCustomRules();
generator.validateCustomRule(rule);

// Template System
generator.generateFromTemplate(templateId);
generator.generateFromGenre(genre);
generator.getAvailableTemplates();

// Export System (via export-templates.js)
exporter.exportTemplates('unity', 'fantasy');
exporter.exportTemplates('godot', 'cyberpunk');
exporter.exportTemplates('typescript', 'space-opera');

// v1.x code - still works perfectly
const generator = new RPGEventGenerator();

// v2.0.0 enhancements - opt-in only
const enhancedGenerator = new RPGEventGenerator({
  enableRuleEngine: true,     // New feature
  pureMarkovMode: false,      // New feature
  templateLibrary: 'fantasy'  // Enhanced feature
});

function onNewGameDay() {
  const dueEvents = generator.advanceGameDay();

  dueEvents.forEach(event => {
    if (event.type === 'time_based_chain') {
      const chainData = generator.timeSystem.timeBasedEvents.get(event.chainId);
      const gameEvent = generator.generateChainEvent(chainData);
      triggerInGameEvent(gameEvent);
    } else if (event.type === 'seasonal_random') {
      const seasonalEvent = generator.generateTimeAwareEvent(playerContext);
      triggerInGameEvent(seasonalEvent);
    }
  });
}

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 <div>No active events</div>;

  return (
    <div className="event-dialog">
      <h2>{currentEvent.title}</h2>
      <p>{currentEvent.description}</p>
      <div className="choices">
        {currentEvent.choices.map((choice, index) => (
          <button
            key={index}
            onClick={() => handleChoice(index)}
            className="choice-button"
          >
            {choice.text}
          </button>
        ))}
      </div>
    </div>
  );
}

// Action Types
export const GENERATE_EVENT = 'GENERATE_EVENT';
export const RESOLVE_EVENT = 'RESOLVE_EVENT';
export const ADVANCE_GAME_DAY = 'ADVANCE_GAME_DAY';

// Action Creators
export const generateEvent = (playerContext) => ({
  type: GENERATE_EVENT,
  payload: { playerContext }
});

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

export const advanceGameDay = () => ({
  type: ADVANCE_GAME_DAY
});

// Reducer
const initialState = {
  generator: new RPGEventGenerator(),
  currentEvent: null,
  gameTime: { day: 1, season: 'spring' }
};

const eventReducer = (state = initialState, action) => {
  switch (action.type) {
    case GENERATE_EVENT:
      const event = state.generator.generateEvent(action.payload.playerContext);
      return { ...state, currentEvent: event };

    case RESOLVE_EVENT:
      // Apply choice effects to player state
      const choice = state.currentEvent.choices[action.payload.choiceIndex];
      const newPlayerState = applyChoiceEffects(choice.effect);
      return {
        ...state,
        currentEvent: null,
        playerState: newPlayerState
      };

    case ADVANCE_GAME_DAY:
      const dueEvents = state.generator.advanceGameDay();
      return {
        ...state,
        gameTime: state.generator.getCurrentTime(),
        dueEvents: dueEvents
      };

    default:
      return state;
  }
};

// Save complete game state
function saveGame(playerState) {
  const gameState = {
    player: playerState,
    events: generator.getGameState(),
    timestamp: Date.now()
  };

  localStorage.setItem('rpgGameSave', JSON.stringify(gameState));
  console.log('Game saved successfully');
}

// Load complete game state
function loadGame() {
  try {
    const savedGame = JSON.parse(localStorage.getItem('rpgGameSave'));
    if (!savedGame) return false;

    // Restore generator state
    generator.loadGameState(savedGame.events);

    // Restore player state
    return savedGame.player;

  } catch (error) {
    console.error('Failed to load game:', error);
    return false;
  }
}