/**
 * AI Interactive Fiction
 * Main client-side logic for web interface
 */
class AIFiction {
  constructor() {
    // DOM elements
    this.storyContainer = document.getElementById('story');
    this.commandHistoryContainer = document.getElementById('command_history');
    this.playerInput = document.getElementById('player_input');
    this.speechButton = document.getElementById('speech');
    this.rewindButton = document.getElementById('rewind');
    this.saveButton = document.getElementById('save');
    this.loadButton = document.getElementById('reload');
    this.speedSlider = document.getElementById('speed');
    this.speedReset = document.getElementById('speed_reset');
    
    // Game state
    this.gameState = {
      started: false,
      currentRoomId: '',
      textSpeed: 50
    };
    
    // Socket connection - ensure we're connecting to the right URL
    this.socket = io(window.location.origin, {
      reconnectionAttempts: 5,
      timeout: 10000
    });
    
    // Typing effect configuration
    this.typingSpeed = 30;  // Default value, will be adjusted by slider
    this.typingTimeout = null;
    
    // Bind event handlers
    this.bindEvents();
    
    // Initialize socket communication
    this.initializeSocket();
    
    // Initialize UI (TTS part will be updated by event)
    this.initializeUI();
    
    // Listen for TTS readiness
    this.listenForTTSReady();
    
    // Set up focus management
    this.setupFocusManagement();
  }
  
  /**
   * Check if kokoro-js is loaded
   */
  checkForKokoroJs() {
    try {
      // With our TTS factory in place, we don't need to manually check for kokoro
      // as the factory will handle loading and fallback automatically
      console.log("TTS Factory will handle initialization of speech systems");
    } catch (e) {
      console.warn("Error checking for TTS systems:", e);
    }
  }
  
  /**
   * Initialize the UI (Initial state, TTS updated later)
   */
  initializeUI() {
    this.updateTypingSpeed();
    // Start with speech button disabled, will be enabled by tts-ready event
    this.speechButton.setAttribute('disabled', 'disabled');
    this.speechButton.setAttribute('title', 'Initializing Text-to-Speech...');
    this.updateSpeechButton(false); 

    // Disable other buttons initially
    this.rewindButton.setAttribute('disabled', 'disabled');
    this.loadButton.setAttribute('disabled', 'disabled');
    
    // Start the game (if socket is ready)
    if (this.socket && this.socket.connected) {
        this.startGame();
    } else {
        console.log("Waiting for socket connection to start game...");
    }
  }
  
  /**
   * Listen for the tts-ready event from the factory
   */
  listenForTTSReady() {
      window.addEventListener('tts-ready', (event) => {
          console.log('Received tts-ready event:', event.detail);
          const { available, type, handler } = event.detail;
          
          if (available) {
              console.log(`TTS System active: ${type}`);
              this.speechButton.removeAttribute('disabled');
              const ttsName = type === 'kokoro' ? 'Kokoro TTS' : 'Browser TTS';
              this.speechButton.setAttribute('title', `Text-to-Speech (${ttsName})`);
              // Ensure the button style reflects the initial state (off)
              this.updateSpeechButton(window.ttsHandler ? window.ttsHandler.isEnabled() : false);
          } else {
              console.warn("No TTS system available after initialization.");
              this.speechButton.setAttribute('disabled', 'disabled');
              this.speechButton.setAttribute('title', 'Text-to-Speech not available');
              this.updateSpeechButton(false);
          }
      });
  }

  /**
   * Helper function to get precise caret coordinates in a textarea
   * @param {HTMLTextAreaElement} element - The textarea element
   * @param {number} position - The caret position
   * @return {Object} Object with top and left coordinates
   */
  getCaretCoordinates(element, position) {
    // Create a range to represent the caret
    const range = document.createRange();
    const textNode = document.createTextNode(element.value.substring(0, position));
    const span = document.createElement('span');
    span.appendChild(textNode);
    
    // Create a temporary div
    const div = document.createElement('div');
    div.style.position = 'absolute';
    div.style.top = '-9999px';
    div.style.left = '-9999px';
    div.style.width = element.offsetWidth + 'px';
    div.style.whiteSpace = 'pre-wrap';
    div.style.wordWrap = 'break-word';
    div.style.fontFamily = window.getComputedStyle(element).fontFamily;
    div.style.fontSize = window.getComputedStyle(element).fontSize;
    div.style.lineHeight = window.getComputedStyle(element).lineHeight;
    div.style.padding = window.getComputedStyle(element).padding;
    
    // Append everything to the DOM
    div.appendChild(span);
    document.body.appendChild(div);
    
    // Measure the position
    const coordinates = {
      top: span.offsetTop,
      left: span.offsetWidth
    };
    
    // Clean up
    document.body.removeChild(div);
    
    return coordinates;
  }

  /**
   * Update the custom cursor position based on input text and caret position
   * Enhanced version with simpler, more reliable positioning
   */
  updateCursorPosition() {
    const input = this.playerInput;
    const cursor = document.getElementById('cursor');
    
    if (!cursor || !input) return;
    
    // Get the current caret position
    const caretPosition = input.selectionStart || 0;
    const inputText = input.value;
    
    if (inputText.length === 0) {
      // If no text, position cursor at the beginning (placeholder visible)
      cursor.style.left = '0px';
      cursor.style.top = '6px'; // Default top position
      return;
    }
    
    // Auto-adjust textarea height based on content
    this.adjustTextareaHeight();
    
    // Use a more reliable method to get cursor position:
    // Create a temporary element that exactly duplicates the input's content and styling
    const div = document.createElement('div');
    div.style.position = 'absolute';
    div.style.top = '-9999px';
    div.style.left = '-9999px';
    div.style.width = getComputedStyle(input).width;
    div.style.height = 'auto';
    div.style.padding = getComputedStyle(input).padding;
    div.style.border = getComputedStyle(input).border;
    div.style.fontFamily = getComputedStyle(input).fontFamily;
    div.style.fontSize = getComputedStyle(input).fontSize;
    div.style.fontWeight = getComputedStyle(input).fontWeight;
    div.style.lineHeight = getComputedStyle(input).lineHeight;
    div.style.whiteSpace = 'pre-wrap';
    div.style.wordWrap = 'break-word';
    div.style.boxSizing = getComputedStyle(input).boxSizing;
    
    // Create three spans to help us position the cursor
    const preCaretText = document.createElement('span');
    preCaretText.textContent = inputText.substring(0, caretPosition);
    
    const caretChar = document.createElement('span');
    caretChar.textContent = '|'; // Visible cursor marker for measurement
    caretChar.style.display = 'inline-block';
    caretChar.style.width = '0';
    
    const postCaretText = document.createElement('span');
    postCaretText.textContent = inputText.substring(caretPosition);
    
    // Add all elements to the DOM
    div.appendChild(preCaretText);
    div.appendChild(caretChar);
    div.appendChild(postCaretText);
    document.body.appendChild(div);
    
    // Get position of the caret marker
    const caretRect = caretChar.getBoundingClientRect();
    const inputRect = input.getBoundingClientRect();
    
    // Set cursor position
    // We need to account for the input's scroll position
    cursor.style.left = (caretRect.left - div.getBoundingClientRect().left) + 'px';
    cursor.style.top = (caretRect.top - div.getBoundingClientRect().top - input.scrollTop) + 'px';
    
    // Clean up
    document.body.removeChild(div);
  }
  
  /**
   * Adjust textarea height based on its content
   */
  adjustTextareaHeight() {
    const textarea = this.playerInput;
    if (!textarea) return;
    
    // Reset height to auto to get the correct scrollHeight
    textarea.style.height = 'auto';
    
    // Set height to scrollHeight to fit content
    textarea.style.height = textarea.scrollHeight + 'px';
  }
  
  /**
   * Bind event handlers to DOM elements
   */
  bindEvents() {
    // Submit command on Enter key without Shift
    this.playerInput.addEventListener('keydown', (e) => {
      if (e.key === 'Enter' && !e.shiftKey) {
        e.preventDefault(); // Prevent default to avoid newline
        this.submitCommand();
      } else if (e.key === 'Enter' && e.shiftKey) {
        // Allow Shift+Enter to create a new line
        // Default behavior happens, no need to do anything
      }
    });
    
    // Auto-resize textarea on input
    this.playerInput.addEventListener('input', () => {
      this.adjustTextareaHeight();
      this.updateCursorPosition();
    });
    
    // Update cursor on various events
    this.playerInput.addEventListener('click', this.updateCursorPosition.bind(this));
    this.playerInput.addEventListener('keyup', this.updateCursorPosition.bind(this));
    this.playerInput.addEventListener('focus', () => {
      document.getElementById('cursor').style.opacity = '1';
      this.updateCursorPosition();
    });
    
    this.playerInput.addEventListener('blur', () => {
      document.getElementById('cursor').style.opacity = '0';
    });
    
    // Handle paste events
    this.playerInput.addEventListener('paste', () => {
      // Use setTimeout to let the paste complete before adjusting
      setTimeout(() => {
        this.adjustTextareaHeight();
        this.updateCursorPosition();
      }, 10);
    });
    
    // Handle window resize
    window.addEventListener('resize', () => {
      this.adjustTextareaHeight();
      this.updateCursorPosition();
    });
    
    // Toggle speech
    this.speechButton.addEventListener('click', () => {
      // Check if the handler is available (it should be if button is enabled)
      if (window.ttsHandler) {
        // Ensure AudioContext is resumed on user interaction if using Kokoro
        if (window.ttsFactory && window.ttsFactory.usingKokoro && window.ttsHandler.audioContext && window.ttsHandler.audioContext.state === 'suspended') {
            window.ttsHandler.audioContext.resume().catch(err => console.error('Error resuming AudioContext on click:', err));
        }
        
        // Set user activation flag for the handler
        window.ttsHandler.hasUserActivation = true; 
        const enabled = window.ttsHandler.toggle();
        this.updateSpeechButton(enabled);
        
        if (enabled) {
          // Speak the last narrative if speech was just enabled
          const lastNarrative = this.storyContainer.lastElementChild;
          if (lastNarrative && lastNarrative.classList.contains('narrative')) {
            console.log("Speaking last narrative on toggle");
            // Use a slight delay to ensure audio context is resumed
            setTimeout(() => window.ttsHandler.speak(lastNarrative.textContent), 50);
          }
          
          // Update the tooltip with active TTS system info
          if (window.ttsFactory) {
            const ttsInfo = window.ttsFactory.getActiveTTSInfo();
            this.speechButton.setAttribute('title', `Text-to-Speech (${ttsInfo.name})`);
          }
        } else {
            // If disabling, ensure speech stops
            window.ttsHandler.stop();
        }
      } else {
        console.log('TTS handler not available when speech button clicked.');
        // Optionally show an alert or keep button disabled
      }
    });
    
    // Restart game
    this.rewindButton.addEventListener('click', () => {
      if (confirm('Are you sure you want to restart the game? All progress will be lost.')) {
        this.startGame();
      }
    });
    
    // Save game
    this.saveButton.addEventListener('click', () => {
      this.socket.emit('saveGame');
    });
    
    // Load game
    this.loadButton.addEventListener('click', () => {
      this.socket.emit('loadGame');
    });
    
    // Adjust typing speed
    this.speedSlider.addEventListener('input', () => {
      this.updateTypingSpeed();
    });
    
    // Reset speed to default
    this.speedReset.addEventListener('click', () => {
      this.speedSlider.value = 50;
      this.updateTypingSpeed();
    });
  }
  
  /**
   * Initialize socket event handlers
   */
  initializeSocket() {
    // Connection established
    this.socket.on('connect', () => {
      console.log('Connected to server');
      // Automatically start the game once connected
      if (!this.gameState.started) {
        this.startGame();
      }
    });
    
    // Connection error
    this.socket.on('connect_error', (error) => {
      console.error('Connection error:', error);
      this.addSystemMessage('Connection error. Please check your network connection and try again.');
    });
    
    // Game introduction received
    this.socket.on('gameIntroduction', (data) => {
      this.clearStory();
      this.addNarrative(data.introduction);
      this.addNarrative(data.initialRoomDescription);
      
      this.gameState.started = true;
      this.gameState.currentRoomId = data.currentRoomId;
      
      // Enable buttons
      this.rewindButton.removeAttribute('disabled');
      
      // Focus on input field
      this.playerInput.focus();
    });
    
    // Narrative response received
    this.socket.on('narrativeResponse', (data) => {
      // Clear any pending "thinking" indicators
      if (this.currentCommandTimeout) {
        clearTimeout(this.currentCommandTimeout);
        this.currentCommandTimeout = null;
        
        // Remove any existing thinking indicators
        document.querySelectorAll('.thinking').forEach(el => el.remove());
      }
      
      this.addNarrative(data.text);
      
      if (data.suggestions && data.suggestions.length > 0) {
        this.addSuggestions(data.suggestions);
      }
      
      // Update game state
      if (data.gameState) {
        this.gameState.currentRoomId = data.gameState.currentRoomId;
      }
      
      // Scroll to bottom and focus input
      this.scrollToBottom();
      this.playerInput.focus(); 
      
      // Re-enable input (failsafe)
      this.playerInput.disabled = false;
    });
    
    // Game saved confirmation
    this.socket.on('gameSaved', () => {
      this.addSystemMessage('Game saved successfully.');
      // Enable load button
      this.loadButton.removeAttribute('disabled');
    });
    
    // Game loaded confirmation
    this.socket.on('gameLoaded', (data) => {
      this.clearStory();
      this.addSystemMessage('Game loaded successfully.');
      this.addNarrative(data.currentRoomDescription);
      
      // Update game state
      this.gameState.currentRoomId = data.currentRoomId;
    });
    
    // Error messages
    this.socket.on('error', (data) => {
      this.addSystemMessage(`Error: ${data.message}`);
    });
  }
  
  /**
   * Start a new game
   */
  startGame() {
    this.clearStory();
    this.addSystemMessage('Starting a new game...');
    this.socket.emit('startGame');
  }
  
  /**
   * Submit a player command
   */
  submitCommand() {
    const command = this.playerInput.value.trim();
    
    if (command === '') return;
    
    // Fade out the input field
    const commandInput = document.getElementById('command_input');
    commandInput.classList.add('fading');
    
    // Disable input temporarily
    this.playerInput.disabled = true;
    
    // Add command to history
    this.addUserCommand(command);
    
    // Add a temporary "thinking" message
    const thinkingId = this.addThinking();
    
    // Send command to server
    this.socket.emit('playerCommand', { command });
    
    // Clear input
    this.playerInput.value = '';
    
    // Reset cursor position to the start
    const cursor = document.getElementById('cursor');
    if (cursor) {
      cursor.style.left = '0px';
      cursor.style.top = '6px';
    }
    
    // Reset textarea height
    this.adjustTextareaHeight();
    
    // Re-enable input field after a short delay (or after 8 seconds as failsafe)
    const timeout = setTimeout(() => {
      // Remove fading class and add fade-in animation
      commandInput.classList.remove('fading');
      commandInput.classList.add('fade-in-input');
      
      // Remove animation class after it completes
      setTimeout(() => {
        commandInput.classList.remove('fade-in-input');
      }, 500);
    
      this.playerInput.disabled = false;
      this.playerInput.focus();
      
      // Remove thinking indicator
      const thinkingElement = document.getElementById(thinkingId);
      if (thinkingElement) {
        thinkingElement.remove();
      }
      
      // Add system message if no response was received (likely timeout)
      if (document.getElementById(thinkingId)) {
        this.addSystemMessage('The server is taking too long to respond. Please try again.');
      }
    }, 8000);
    
    // Store the timeout so it can be cleared if we get a response
    this.currentCommandTimeout = timeout;
  }
  
  /**
   * Add a user command to the story
   */
  addUserCommand(command) {
    const element = document.createElement('p');
    element.className = 'user-input';
    element.textContent = `> ${command}`;
    this.storyContainer.appendChild(element);
    this.scrollToBottom();
  }
  
  /**
   * Add a narrative response with typing effect
   */
  addNarrative(text) {
    const element = document.createElement('p');
    element.className = 'narrative hide';
    this.storyContainer.appendChild(element);
    
    // Apply SmartyPants transformations for better typography if available
    const processedText = window.SmartyPants && typeof window.SmartyPants.smartypantsu === 'function' 
      ? window.SmartyPants.smartypantsu(text, 1) 
      : text;
    
    // Clear any existing typing timeouts
    if (this.typingTimeout) {
      clearTimeout(this.typingTimeout);
    }
    
    // Add the text with a typing effect
    this.typeText(element, processedText, 0);
    
    // Read text aloud if speech is enabled
    if (window.ttsHandler && window.ttsHandler.isEnabled()) {
      console.log("Speaking narrative text with TTS");
      window.ttsHandler.speak(text);
    }
  }
  
  /**
   * Add suggestions to the story
   */
  addSuggestions(suggestions) {
    const element = document.createElement('div');
    element.className = 'suggestions';
    
    const heading = document.createElement('p');
    heading.textContent = 'Suggestions:';
    heading.style.fontStyle = 'italic';
    heading.style.marginTop = '1rem';
    element.appendChild(heading);
    
    const list = document.createElement('ul');
    suggestions.forEach(suggestion => {
      const item = document.createElement('li');
      item.textContent = suggestion;
      
      // Make suggestions clickable
      item.style.cursor = 'pointer';
      item.addEventListener('click', () => {
        this.playerInput.value = suggestion;
        this.submitCommand();
      });
      
      list.appendChild(item);
    });
    element.appendChild(list);
    
    this.storyContainer.appendChild(element);
    this.scrollToBottom();
  }
  
  /**
   * Add a system message
   */
  addSystemMessage(message) {
    const element = document.createElement('p');
    element.className = 'system-message';
    element.textContent = message;
    element.style.fontStyle = 'italic';
    element.style.color = '#555';
    this.storyContainer.appendChild(element);
    this.scrollToBottom();
  }
  
  /**
   * Add a thinking indicator
   */
  addThinking() {
    const id = 'thinking-' + Date.now();
    const element = document.createElement('div');
    element.id = id;
    element.className = 'thinking';
    element.innerHTML = '<p>Thinking<span class="loading-indicator"><span>.</span><span>.</span><span>.</span></span></p>';
    element.style.fontStyle = 'italic';
    element.style.color = '#777';
    this.storyContainer.appendChild(element);
    this.scrollToBottom();
    return id;
  }
  
  /**
   * Clear the story container
   */
  clearStory() {
    while (this.storyContainer.firstChild) {
      this.storyContainer.removeChild(this.storyContainer.firstChild);
    }
  }
  
  /**
   * Type text into an element character by character
   */
  typeText(element, text, index) {
    // Show the element if it was hidden
    if (index === 0) {
      element.classList.remove('hide');
    }
    
    // Set the current text
    element.textContent = text.substring(0, index);
    
    // If we haven't reached the end of the text
    if (index < text.length) {
      // Calculate delay (randomize slightly for more natural effect)
      const delay = Math.max(10, 100 - this.gameState.textSpeed) / 5;
      const randomDelay = delay * (0.8 + Math.random() * 0.4);
      
      // Schedule the next character
      this.typingTimeout = setTimeout(() => {
        this.typeText(element, text, index + 1);
      }, randomDelay);
    } else {
      // Finished typing
      this.scrollToBottom();
    }
  }
  
  /**
   * Update the typing speed based on the slider value
   */
  updateTypingSpeed() {
    this.gameState.textSpeed = parseInt(this.speedSlider.value, 10);
  }
  
  /**
   * Update the speech button styling
   */
  updateSpeechButton(enabled = false) {
    if (enabled) {
      this.speechButton.style.fontWeight = 'bold';
      this.speechButton.style.color = '#000';
      this.speechButton.style.backgroundColor = '#eee';
    } else {
      this.speechButton.style.fontWeight = 'normal';
      this.speechButton.style.color = '#333';
      this.speechButton.style.backgroundColor = '';
    }
  }
  
  /**
   * Scroll the story container to the bottom
   */
  scrollToBottom() {
    const container = document.getElementById('page_right');
    if (container) {
      container.scrollTop = container.scrollHeight;
    }
  }
  
  /**
   * Set up focus management to ensure input field is always focused
   */
  setupFocusManagement() {
    // Focus input field when the page loads
    window.addEventListener('load', () => {
      // Force immediate focus on load
      this.playerInput.focus();
      
      // Some browsers might need a slight delay
      setTimeout(() => this.playerInput.focus(), 100);
      
      // Also adjust textarea height and update cursor position
      this.adjustTextareaHeight();
      this.updateCursorPosition();
    });
    
    // Focus input when user clicks anywhere in the document
    document.addEventListener('click', (e) => {
      // Don't steal focus if user is clicking on a button or link
      if (
        e.target.tagName !== 'BUTTON' && 
        e.target.tagName !== 'A' && 
        !e.target.classList.contains('suggestions') &&
        !e.target.closest('.suggestions')
      ) {
        this.playerInput.focus();
      }
    });
    
    // Re-focus input when user returns to this browser tab
    window.addEventListener('focus', () => {
      this.playerInput.focus();
    });
    
    // Re-focus input when user returns to the window 
    window.addEventListener('visibilitychange', () => {
      if (document.visibilityState === 'visible') {
        setTimeout(() => this.playerInput.focus(), 100);
      }
    });
    
    // Focus on input after narrative is added
    const originalAddNarrative = this.addNarrative.bind(this);
    this.addNarrative = (text) => {
      originalAddNarrative(text);
      // Short timeout to ensure rendering completes
      setTimeout(() => this.playerInput.focus(), 10);
    };
  }
}

// Create the application when the DOM is fully loaded
document.addEventListener('DOMContentLoaded', () => {
  // Set custom CSS variables based on viewport
  const updateViewportVariables = () => {
    const vw = window.innerWidth;
    const vh = window.innerHeight;
    document.documentElement.style.setProperty('--viewport-aspect-ratio', `${vw / vh}`);
    
    // Adjust book size based on viewport
    const bookWidth = Math.min(vw * 0.9, vh * 1.4);
    const bookHeight = bookWidth / 1.613;
    document.documentElement.style.setProperty('--book-width', `${bookWidth}px`);
    document.documentElement.style.setProperty('--book-height', `${bookHeight}px`);
  };
  
  // Update variables initially and on resize
  updateViewportVariables();
  window.addEventListener('resize', updateViewportVariables);
  
  // Initialize the application
  window.app = new AIFiction();
});