import { createQNCEEngine } from 'qnce-engine';

const storyData = {
  currentNodeId: 'town-square',
  nodes: {
    'town-square': {
      id: 'town-square',
      text: 'You stand in the bustling town square.',
      choices: [
        {
          id: 'enter-tavern',
          text: 'Enter the tavern',
          nextNodeId: 'tavern-inside'
        },
        {
          id: 'approach-guard',
          text: 'Approach the suspicious guard',
          nextNodeId: 'guard-encounter',
          condition: 'flags.curiosity >= 3'  // Only show if curious enough
        },
        {
          id: 'use-disguise',
          text: 'Use your disguise to blend in',
          nextNodeId: 'disguised-approach',
          condition: 'flags.hasDisguise && !flags.disguiseUsed'
        }
      ]
    }
  },
  flags: {}
};

const engine = createQNCEEngine(storyData);

// Set flags to test conditional choices
engine.setFlag('curiosity', 4);
engine.setFlag('hasDisguise', true);

// Get available choices - only those meeting conditions
const choices = engine.getAvailableChoices();
console.log(`Available choices: ${choices.length}`); // Shows 3 choices

// Change flags to see different options
engine.setFlag('curiosity', 1); // Below threshold
const reducedChoices = engine.getAvailableChoices();
console.log(`Available choices: ${reducedChoices.length}`); // Shows 2 choices

const complexStory = {
  currentNodeId: 'critical-moment',
  nodes: {
    'critical-moment': {
      id: 'critical-moment',
      text: 'The fate of the kingdom hangs in the balance.',
      choices: [
        {
          id: 'diplomatic-solution',
          text: 'Attempt diplomatic negotiation',
          nextNodeId: 'peaceful-resolution',
          condition: 'flags.charisma >= 5 && flags.hasAlliance'
        },
        {
          id: 'magical-intervention',
          text: 'Cast the ancient spell',
          nextNodeId: 'magical-outcome',
          condition: 'flags.magicPower > 3 && flags.spellComponents >= 2 && !flags.cursed'
        },
        {
          id: 'time-limited-escape',
          text: 'Escape through the secret passage',
          id: 'sacrifice-play',
          text: 'Make the ultimate sacrifice',
          nextNodeId: 'heroic-end',
          condition: '(flags.loyalty >= 8 || flags.desperate) && flags.hasArtifact'
        }
      ]
    }
  },
  flags: {}
};

// Set up custom evaluator for complex game logic
engine.setConditionEvaluator((expression, context) => {
  // Custom logic for special conditions
  if (expression === 'canUseSpecialAbility') {
    return context.flags.level >= 10 && 
           context.flags.mana > 50 && 
           !context.flags.abilityOnCooldown;
  }
  
  if (expression.startsWith('inventory:')) {
    const itemName = expression.replace('inventory:', '');
    return context.flags[`has_${itemName}`] === true;
  }
  
  // Fall back to default expression evaluation
  return null;
});

// Use custom conditions in story
const storyWithCustom = {
  currentNodeId: 'boss-fight',
  nodes: {
    'boss-fight': {
      id: 'boss-fight',
      text: 'The dragon roars menacingly.',
      choices: [
        {
          id: 'special-attack',
          text: 'Use your special ability',
          nextNodeId: 'special-victory',
          condition: 'canUseSpecialAbility'
        },
        {
          id: 'use-potion',
          text: 'Drink healing potion',
          nextNodeId: 'healed-state',
          condition: 'inventory:healing_potion'
        }
      ]
    }
  }
};

// Validate conditions during development
try {
  engine.validateCondition('flags.strength >= 5 && flags.weapon');
  console.log('Condition is valid');
} catch (error) {
  console.error('Invalid condition:', error.message);
}

// Get flags referenced in a condition for debugging
const referencedFlags = engine.getConditionFlags('flags.curiosity >= 3 && flags.hasKey');
console.log('Referenced flags:', referencedFlags); // ['curiosity', 'hasKey']

// Clear custom evaluator
engine.clearConditionEvaluator();

import { createQNCEEngine, DEMO_STORY } from 'qnce-engine';

// Create engine instance with demo story
const engine = createQNCEEngine(DEMO_STORY);

// Get current narrative state
const currentNode = engine.getCurrentNode();
console.log(currentNode.text);

// Get available choices
const choices = engine.getAvailableChoices();
console.log(choices);

// Make a choice
if (choices.length > 0) {
  engine.selectChoice(choices[0]);
}

// Check narrative flags
const flags = engine.getFlags();
console.log('Current flags:', flags);

import { createQNCEEngine, DEMO_STORY } from 'qnce-engine';

// Enable performance optimizations
const engine = createQNCEEngine(DEMO_STORY, {}, true, {
  maxWorkers: 4,
  enableProfiling: true
});

// Background cache preloading happens automatically
// Object pooling reduces memory allocations by 90%+
// Performance events are collected for monitoring

// Get performance statistics
const poolStats = engine.getPoolStats();
console.log(`Pool efficiency: ${poolStats.flow.hitRate}%`);

import { createQNCEEngine, DEMO_STORY } from 'qnce-engine';

const engine = createQNCEEngine(DEMO_STORY);

// ...progress through the story...
const choices = engine.getAvailableChoices();
if (choices.length > 0) {
  engine.selectChoice(choices[0]);
}


// Save the current state to a JSON string
const savedState = await engine.saveState();
console.log('State saved!');

// ...later, or in a new session...

// Create a new engine instance
const newEngine = createQNCEEngine(DEMO_STORY);

// Load the state
await newEngine.loadState(JSON.parse(savedState));

console.log('State loaded successfully!');
console.log('Current Node:', newEngine.getCurrentNode().text);

// Create a lightweight checkpoint
const checkpoint = await engine.createCheckpoint('Before a risky choice');

// ...make a choice...

// Restore to the checkpoint
await engine.restoreFromCheckpoint(checkpoint.id);
console.log('Restored to checkpoint:', engine.getCurrentNode().text);

import { createQNCEEngine, DEMO_STORY } from 'qnce-engine';

const engine = createQNCEEngine(DEMO_STORY);

// Autosave is enabled by default and will track state changes automatically
console.log('Can undo:', engine.canUndo()); // false initially

// Make some choices (autosave will track each change)
const choices = engine.getAvailableChoices();
engine.selectChoice(choices[0]);

console.log('Can undo:', engine.canUndo()); // true after making a choice

// Undo the last action
const undoResult = engine.undo();
if (undoResult.success) {
  console.log('Undid:', undoResult.description);
  console.log('Can redo:', engine.canRedo()); // true
}

// Redo the undone action
const redoResult = engine.redo();
if (redoResult.success) {
  console.log('Redid:', redoResult.description);
}

// Get history summary
const history = engine.getHistorySummary();
console.log(`History: ${history.undoCount} undo, ${history.redoCount} redo entries`);

// Configure undo/redo system
engine.configureUndoRedo({
  maxUndoEntries: 100,    // Maximum undo operations to remember
  maxRedoEntries: 50,     // Maximum redo operations to remember
  enabled: true           // Enable/disable undo/redo tracking
});

// Configure autosave behavior
engine.configureAutosave({
  enabled: true,          // Enable/disable autosave
  throttleMs: 100,        // Minimum time between saves (milliseconds)
  events: ['choice', 'flag', 'load'] // Which events trigger autosave
});

// Manual autosave trigger
await engine.autosave();

// Clear all undo/redo history
engine.clearHistory();

import { createQNCEEngine, createBranchingEngine } from 'qnce-engine';

// Create core engine
const engine = createQNCEEngine(storyData);

// Enable advanced branching
const branchingEngine = engine.enableBranching(advancedStoryData);

// Evaluate available branches
const branches = await branchingEngine.evaluateAvailableBranches();
console.log(`Available paths: ${branches.length}`);

// Execute a narrative branch
await branchingEngine.executeBranch(branches[0].id);

// Set AI context for personalized content
branchingEngine.setAIContext({
  playerProfile: {
    playStyle: 'explorer',
    preferences: { adventure: 0.8, mystery: 0.6 },
    historicalChoices: ['brave-path', 'investigate-clue']
  },
  narrativeContext: {
    currentTone: 'mysterious',
    thematicElements: ['exploration', 'discovery'],
    plotTension: 0.7
  }
});

// Generate AI-enhanced branches
const aiBranches = await branchingEngine.generateAIBranches(3);
console.log('AI-generated options:', aiBranches.map(b => b.displayText));

// Insert new branch at runtime
const dynamicBranch = {
  type: 'insert',
  branchId: 'special-event',
  targetLocation: { chapterId: 'main', nodeId: 'crossroads' },
  payload: {
    name: 'Special Event',
    branchOptions: [{
      id: 'event-choice',
      displayText: 'Investigate the mysterious sound',
      flagEffects: { event_discovered: true }
    }]
  }
};

await branchingEngine.insertDynamicBranch(dynamicBranch);

// Remove branch when no longer needed
await branchingEngine.removeDynamicBranch('special-event');

// Get branching analytics
const analytics = branchingEngine.getBranchingAnalytics();
console.log(`Branches traversed: ${analytics.totalBranchesTraversed}`);
console.log(`Popular choices: ${analytics.mostPopularBranches}`);

// Export comprehensive data
const exportData = branchingEngine.exportBranchingData();
// Contains: story structure, session data, player behavior, performance metrics

// Enable all performance optimizations
const engine = createQNCEEngine(storyData, {}, true, {
  maxWorkers: 4,           // Background processing
  enableProfiling: true    // Performance monitoring
});

// Object pooling and background caching happen automatically
// Monitor performance in real-time with CLI dashboard

import { useQNCE, useUndoRedo, useAutosave } from 'qnce-engine/react';
import { DEMO_STORY } from 'qnce-engine';

function NarrativeComponent() {
  // Core narrative hook
  const { engine, currentNode, choices, flags, selectChoice, resetNarrative } = useQNCE(DEMO_STORY);
  
  // Undo/redo functionality
  const { 
    undo, 
    redo, 
    canUndo, 
    canRedo, 
    undoCount, 
    redoCount,
    clearHistory 
  } = useUndoRedo(engine);
  
  // Autosave status
  const { isAutosaveEnabled, lastAutosave } = useAutosave(engine);

  return (
    <div>
      <h2>Current Scene</h2>
      <p>{currentNode.text}</p>
      
      <h3>Choices</h3>
      {choices.map((choice, index) => (
        <button key={index} onClick={() => selectChoice(choice)}>
          {choice.text}
        </button>
      ))}
      
      <div className="controls">
        <button onClick={undo} disabled={!canUndo}>
          Undo ({undoCount})
        </button>
        <button onClick={redo} disabled={!canRedo}>
          Redo ({redoCount})
        </button>
        <button onClick={resetNarrative}>Reset</button>
        <button onClick={clearHistory}>Clear History</button>
      </div>
      
      <div className="status">
        <p>Autosave: {isAutosaveEnabled ? 'Enabled' : 'Disabled'}</p>
        {lastAutosave && <p>Last saved: {lastAutosave.toLocaleTimeString()}</p>}
      </div>
      
      <details>
        <summary>Debug Info</summary>
        <pre>{JSON.stringify(flags, null, 2)}</pre>
      </details>
    </div>
  );
}

import { UndoRedoControls } from 'qnce-engine/ui';
import { createQNCEEngine } from 'qnce-engine';

function MyApp() {
  const engine = createQNCEEngine(DEMO_STORY);

  return (
    <div>
      {/* Narrative content */}
      
      {/* Undo/Redo Controls */}
      <UndoRedoControls 
        engine={engine}
        size="md"              // sm, md, lg
        layout="horizontal"    // horizontal, vertical  
        showLabels={true}      // Show text labels
        labels={{              // Custom labels
          undo: "Go Back",
          redo: "Go Forward"
        }}
        onUndo={(result) => console.log('Undo:', result)}
        onRedo={(result) => console.log('Redo:', result)}
        theme={{               // Custom theming
          colors: {
            primary: '#007bff',
            disabled: '#6c757d'
          },
          borderRadius: { md: '8px' }
        }}
      />
    </div>
  );
}

import { AutosaveIndicator } from 'qnce-engine/ui';

function MyApp() {
  const engine = createQNCEEngine(DEMO_STORY);

  return (
    <div>
      {/* Narrative content */}
      
      {/* Autosave Status */}
      <AutosaveIndicator 
        engine={engine}
        variant="detailed"     // minimal, detailed, icon-only
        position="top-right"   // inline, top-right, bottom-left, etc.
        showTimestamp={true}   // Show last save time
        autoHideDelay={3000}   // Auto-hide after 3 seconds
        messages={{            // Custom messages
          idle: "Ready to save",
          saving: "Saving...",
          saved: "All changes saved",
          error: "Save failed"
        }}
        theme={{               // Custom theming
          colors: {
            success: '#28a745',
            error: '#dc3545',
            warning: '#ffc107'
          }
        }}
      />
    </div>
  );
}

import { useKeyboardShortcuts } from 'qnce-engine/ui';

function MyApp() {
  const engine = createQNCEEngine(DEMO_STORY);
  
  // Enable keyboard shortcuts
  useKeyboardShortcuts(engine, {
    undo: ['ctrl+z', 'cmd+z'],      // Undo shortcuts
    redo: ['ctrl+y', 'cmd+shift+z'], // Redo shortcuts  
    save: ['ctrl+s', 'cmd+s'],       // Manual save
    disabled: false                  // Enable/disable all shortcuts
  });

  return (
    <div>
      {/* Your narrative UI */}
      <p>Press Ctrl+Z to undo, Ctrl+Y to redo, Ctrl+S to save</p>
    </div>
  );
}

import { createQNCEEngine } from 'qnce-engine';
import { useState, useCallback } from 'react';

function useQNCE(storyData) {
  const [engine] = useState(() => createQNCEEngine(storyData));
  const [currentNode, setCurrentNode] = useState(engine.getCurrentNode());
  const [flags, setFlags] = useState(engine.getFlags());

  const selectChoice = useCallback((choice) => {
    engine.selectChoice(choice);
    setCurrentNode(engine.getCurrentNode());
    setFlags(engine.getFlags());
  }, [engine]);

  const goToNodeById = useCallback((nodeId) => {
    engine.goToNodeById(nodeId);
    setCurrentNode(engine.getCurrentNode());
    setFlags(engine.getFlags());
  }, [engine]);

  return { currentNode, flags, selectChoice, goToNodeById };
}

import { createQNCEEngine } from 'qnce-engine';
import { ref, reactive } from 'vue';

export function useQNCE(storyData) {
  const engine = createQNCEEngine(storyData);
  const currentNode = ref(engine.getCurrentNode());
  const flags = reactive(engine.getFlags());

  const selectChoice = (choice) => {
    engine.selectChoice(choice);
    currentNode.value = engine.getCurrentNode();
    Object.assign(flags, engine.getFlags());
  };

  return { currentNode, flags, selectChoice };
}

import { createQNCEEngine, loadStoryData } from 'qnce-engine';
import { readFileSync } from 'fs';
import * as readline from 'readline';

const storyData = loadStoryData(JSON.parse(readFileSync('story.json', 'utf-8')));
const engine = createQNCEEngine(storyData);

async function playStory() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  while (true) {
    const node = engine.getCurrentNode();
    console.log('\n' + node.text);
    
    if (node.choices.length === 0) break;
    
    node.choices.forEach((choice, i) => {
      console.log(`${i + 1}. ${choice.text}`);
    });
    
    // Get user input and make choice...
  }
}

import { createQNCEEngine } from 'qnce-engine';

const engine = createQNCEEngine(storyData);

try {
  // makeChoice() automatically validates before executing
  engine.makeChoice(0);
} catch (error) {
  if (error instanceof ChoiceValidationError) {
    console.error('Invalid choice:', error.message);
    console.log('Available choices:', error.availableChoices);
  }
}

// Choice with flag requirements
const flagBasedChoice = {
  text: 'Use the magic key',
  nextNodeId: 'unlock_door',
  flagRequirements: {
    hasKey: true,
    playerLevel: 5
  }
};

// Choice with inventory requirements
const inventoryChoice = {
  text: 'Buy expensive sword',
  nextNodeId: 'shop_success',
  inventoryRequirements: {
    gold: 1000,
    gems: 2
  }
};

// Time-based availability
const timedChoice = {
  text: 'Enter the tavern',
  nextNodeId: 'tavern',
  timeRequirements: {
    availableAfter: new Date('2025-01-01T18:00:00'),
    availableBefore: new Date('2025-01-01T24:00:00')
  }
};

// Disabled choice
const disabledChoice = {
  text: 'Broken bridge',
  nextNodeId: 'fall',
  enabled: false
};

import { 
  StandardValidationRules, 
  createChoiceValidator 
} from 'qnce-engine';

const validator = createChoiceValidator();

// Add custom rule
validator.addRule({
  name: 'custom-rule',
  priority: 10,
  validate: (choice, context) => {
    // Your custom logic
    if (choice.text.includes('danger') && !context.state.flags.brave) {
      return {
        isValid: false,
        reason: 'You must be brave to take this path!',
        failedConditions: ['requires-bravery']
      };
    }
    return { isValid: true };
  }
});

// Apply to engine
engine.setChoiceValidator(validator);

import { 
  ChoiceValidationError, 
  isChoiceValidationError 
} from 'qnce-engine';

try {
  engine.makeChoice(2);
} catch (error) {
  if (isChoiceValidationError(error)) {
    // Get user-friendly message
    const message = error.getUserFriendlyMessage();
    console.log(message);
    
    // Get debug information
    const debugInfo = error.getDebugInfo();
    console.log('Failed conditions:', debugInfo.validationResult.failedConditions);
    
    // Show alternatives
    console.log('Available choices:');
    error.availableChoices?.forEach((choice, i) => {
      console.log(`${i + 1}. ${choice.text}`);
    });
  }
}