/**
 * Application State
 *
 * Singleton класс для управления глобальным состоянием приложения.
 */

import { defaultSettings, defaultEnvironmentState } from '../data/defaults.js'
import {
  saveEnvironmentData,
  loadEnvironmentData,
  saveSettings,
  loadSettings
} from '../data/storage.js'

/**
 * AppState class - manages global application state
 * Implements Singleton pattern
 */
class AppState {
  constructor() {
    if (AppState.instance) {
      return AppState.instance
    }

    // Settings from server
    this.settings = null

    // Current active environment: 'ift', 'psi', or 'prod'
    this.currentEnvironment = 'ift'

    // Environment-specific runtime data
    this.environments = {
      ift: { ...defaultEnvironmentState },
      psi: { ...defaultEnvironmentState },
      prod: { ...defaultEnvironmentState }
    }

    AppState.instance = this
  }

  /**
   * Get current environment
   * @returns {string} Current environment name
   */
  getCurrentEnvironment() {
    return this.currentEnvironment
  }

  /**
   * Set current environment
   * @param {string} env - Environment name ('ift', 'psi', 'prod')
   */
  setCurrentEnvironment(env) {
    if (!['ift', 'psi', 'prod'].includes(env)) {
      console.error(`Invalid environment: ${env}`)
      return
    }

    this.currentEnvironment = env
  }

  /**
   * Get current environment state
   * @returns {object} Current environment state
   */
  getCurrentEnv() {
    return this.environments[this.currentEnvironment]
  }

  /**
   * Get current environment settings
   * @returns {object} Current environment settings
   */
  getCurrentEnvSettings() {
    if (!this.settings) {
      return null
    }

    return this.settings.environments[this.currentEnvironment]
  }

  /**
   * Get environment state by name
   * @param {string} env - Environment name
   * @returns {object} Environment state
   */
  getEnvironment(env) {
    return this.environments[env]
  }

  /**
   * Set settings
   * @param {object} settings - Settings object from server
   */
  setSettings(settings) {
    this.settings = settings

    // Update current environment from settings
    if (settings.activeEnvironment) {
      this.setCurrentEnvironment(settings.activeEnvironment)
    }
  }

  /**
   * Update settings
   * @param {object} updates - Settings updates
   */
  updateSettings(updates) {
    if (!this.settings) {
      this.settings = { ...defaultSettings }
    }

    this.settings = {
      ...this.settings,
      ...updates
    }

    // Update current environment if changed
    if (updates.activeEnvironment) {
      this.setCurrentEnvironment(updates.activeEnvironment)
    }
  }

  /**
   * Update environment-specific settings
   * @param {string} env - Environment name
   * @param {object} envSettings - Environment settings updates
   */
  updateEnvironmentSettings(env, envSettings) {
    if (!this.settings) {
      this.settings = { ...defaultSettings }
    }

    if (!this.settings.environments) {
      this.settings.environments = {}
    }

    this.settings.environments[env] = {
      ...this.settings.environments[env],
      ...envSettings
    }
  }

  /**
   * Set current request for environment
   * @param {string} env - Environment name
   * @param {object} request - Request object
   */
  setRequest(env, request) {
    this.environments[env].currentRequest = request
  }

  /**
   * Set current response for environment
   * @param {string} env - Environment name
   * @param {object} response - Response object
   */
  setResponse(env, response) {
    this.environments[env].currentResponse = response
  }

  /**
   * Set request metadata
   * @param {string} env - Environment name
   * @param {string} requestId - Request ID
   * @param {string} timestamp - Request timestamp
   */
  setRequestMetadata(env, requestId, timestamp) {
    this.environments[env].requestId = requestId
    this.environments[env].requestTimestamp = timestamp
  }

  /**
   * Set current answer index
   * @param {string} env - Environment name
   * @param {number} index - Answer index
   */
  setCurrentAnswerIndex(env, index) {
    this.environments[env].currentAnswerIndex = index
  }

  /**
   * Set annotations for environment
   * @param {string} env - Environment name
   * @param {object} annotations - Annotations object
   */
  setAnnotations(env, annotations) {
    this.environments[env].annotations = annotations
  }

  /**
   * Get annotations for environment
   * @param {string} env - Environment name
   * @returns {object} Annotations object
   */
  getAnnotations(env) {
    return this.environments[env].annotations || {}
  }

  /**
   * Clear environment data
   * @param {string} env - Environment name
   */
  clearEnvironment(env) {
    this.environments[env] = { ...defaultEnvironmentState }
  }

  /**
   * Save environment data to localStorage
   * @param {string} env - Environment name
   */
  saveEnvironmentToStorage(env) {
    const data = this.environments[env]
    saveEnvironmentData(env, data)
  }

  /**
   * Load environment data from localStorage
   * @param {string} env - Environment name
   */
  loadEnvironmentFromStorage(env) {
    const data = loadEnvironmentData(env)

    if (data) {
      this.environments[env] = data
    }
  }

  /**
   * Save settings to localStorage
   */
  saveSettingsToStorage() {
    if (this.settings) {
      saveSettings(this.settings)
    }
  }

  /**
   * Load settings from localStorage
   */
  loadSettingsFromStorage() {
    const settings = loadSettings()

    if (settings) {
      this.setSettings(settings)
    }
  }

  /**
   * Load all data from localStorage
   */
  loadAllFromStorage() {
    this.loadSettingsFromStorage()

    const environments = ['ift', 'psi', 'prod']
    environments.forEach(env => this.loadEnvironmentFromStorage(env))
  }

  /**
   * Save all data to localStorage
   */
  saveAllToStorage() {
    this.saveSettingsToStorage()

    const environments = ['ift', 'psi', 'prod']
    environments.forEach(env => this.saveEnvironmentToStorage(env))
  }

  /**
   * Reset to default state
   */
  reset() {
    this.settings = null
    this.currentEnvironment = 'ift'
    this.environments = {
      ift: { ...defaultEnvironmentState },
      psi: { ...defaultEnvironmentState },
      prod: { ...defaultEnvironmentState }
    }
  }
}

// Create singleton instance
const appState = new AppState()

// Export singleton instance as default export
export default appState

// Export class for testing purposes
export { AppState }