/**
 * @fileoverview Simple usage example for Node.js environment
 * @author Owen Animation System
 */

import { OwenSystemFactory, States } from '../../src/index.js'

/**
 * Simple example of using Owen Animation System
 * This example shows how to use the system without a browser environment
 */
class SimpleOwenExample {
  constructor () {
    this.owenSystem = null
  }

  /**
   * Initialize the Owen system with a mock model
   * @returns {Promise<void>}
   */
  async init () {
    try {
      // Create a mock GLTF model for demonstration
      const mockModel = this.createMockModel()

      // Create the Owen system
      this.owenSystem = await OwenSystemFactory.createBasicOwenSystem(mockModel)

      console.log('✅ Owen Animation System initialized successfully!')
      console.log('📊 System Info:')
      console.log(`   Available States: ${this.owenSystem.getAvailableStates().join(', ')}`)
      console.log(`   Current State: ${this.owenSystem.getCurrentState()}`)

      // Run some example interactions
      await this.runExamples()
    } catch (error) {
      console.error('❌ Failed to initialize Owen system:', error.message)
    }
  }

  /**
   * Create a mock 3D model for demonstration purposes
   * @returns {Object} Mock model object
   */
  createMockModel () {
    return {
      animations: [
        { name: 'wait_idle_L' },
        { name: 'wait_quirk1_Q' },
        { name: 'wait_quirk2_Q' },
        { name: 'react_idle_L' },
        { name: 'react_angry_Q' },
        { name: 'react_happy_Q' },
        { name: 'type_idle_L' },
        { name: 'type_angry_L' },
        { name: 'sleep_idle_L' },
        { name: 'wait_2react_T' },
        { name: 'react_2type_T' },
        { name: 'type_2wait_T' },
        { name: 'wait_2sleep_T' },
        { name: 'sleep_2wait_T' }
      ],
      scene: {},
      userData: {}
    }
  }

  /**
   * Run example interactions with the Owen system
   * @returns {Promise<void>}
   */
  async runExamples () {
    console.log('\n🎬 Running example interactions...\n')

    // Example 1: Basic state transitions
    console.log('📝 Example 1: Manual state transitions')
    await this.demonstrateStateTransitions()

    // Example 2: Message handling
    console.log('\n📝 Example 2: Message handling with emotions')
    await this.demonstrateMessageHandling()

    // Example 3: System update loop
    console.log('\n📝 Example 3: System update simulation')
    this.demonstrateUpdateLoop()

    console.log('\n✨ All examples completed!')
  }

  /**
   * Demonstrate manual state transitions
   * @returns {Promise<void>}
   */
  async demonstrateStateTransitions () {
    const states = [States.REACT, States.TYPE, States.WAIT, States.SLEEP]

    for (const state of states) {
      console.log(`🔄 Transitioning to ${state.toUpperCase()} state...`)
      await this.owenSystem.transitionTo(state)
      console.log(`   ✓ Current state: ${this.owenSystem.getCurrentState()}`)
      console.log(`   ✓ Available transitions: ${this.owenSystem.getAvailableTransitions().join(', ')}`)

      // Simulate some time passing
      await this.sleep(500)
    }
  }

  /**
   * Demonstrate message handling with emotional responses
   * @returns {Promise<void>}
   */
  async demonstrateMessageHandling () {
    const messages = [
      { text: 'Hello Owen!', expected: 'neutral response' },
      { text: 'This is urgent!', expected: 'angry/urgent response' },
      { text: 'Great work!', expected: 'happy response' },
      { text: 'There\'s an error in the system', expected: 'shocked response' },
      { text: 'I\'m feeling sad today', expected: 'sad response' }
    ]

    for (const message of messages) {
      console.log(`💬 Sending message: "${message.text}"`)
      console.log(`   Expected: ${message.expected}`)

      await this.owenSystem.handleUserMessage(message.text)
      console.log(`   ✓ Current state after message: ${this.owenSystem.getCurrentState()}`)

      await this.sleep(300)
    }
  }

  /**
   * Demonstrate the system update loop
   * @returns {void}
   */
  demonstrateUpdateLoop () {
    console.log('⏱️  Simulating update loop for 3 seconds...')

    let iterations = 0
    const startTime = Date.now()

    const updateLoop = () => {
      const deltaTime = 16.67 // ~60 FPS
      this.owenSystem.update(deltaTime)
      iterations++

      if (Date.now() - startTime < 3000) {
        setTimeout(updateLoop, 16)
      } else {
        console.log(`   ✓ Completed ${iterations} update iterations`)
        console.log(`   ✓ Final state: ${this.owenSystem.getCurrentState()}`)
      }
    }

    updateLoop()
  }

  /**
   * Simple sleep utility for demonstrations
   * @param {number} ms - Milliseconds to sleep
   * @returns {Promise<void>}
   */
  sleep (ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
  }
}

// Run the example if this file is executed directly
if (import.meta.url === `file://${process.argv[1]}`) {
  console.log('🚀 Starting Owen Animation System Example\n')

  const example = new SimpleOwenExample()
  example.init()
    .then(() => {
      console.log('\n🎉 Example completed successfully!')
      console.log('💡 Try modifying this example or check out the browser demo in examples/index.html')
    })
    .catch(error => {
      console.error('\n💥 Example failed:', error)
    })
}

export default SimpleOwenExample