vue-pult/client/src/composables/config/useConfigESP.js

import { ref, computed } from 'vue'
import { useWebSocketGlobal } from '@/composables/useWebSocketGlobal'
import { useLogger } from '@/composables/useLogger'

const logger = useLogger('useConfigESP')

// Настройки ESP с валидацией
const ESP_CONFIG_SCHEMA = {
  hz: {
    label: 'Частота (Hz)',
    min: 9999,
    max: 100000,
    default: 14000,
    description: 'Частота работы ESP модуля'
  },
  MaxTime: {
    label: 'Максимальное время (ms)',
    min: 1000,
    max: 200000,
    default: 140000,
    description: 'Максимальное время работы'
  },
  maxShot: {
    label: 'Максимум выстрелов',
    min: 1,
    max: 100,
    default: 2,
    description: 'Максимальное количество выстрелов'
  },
  maxA: {
    label: 'Максимальная амплитуда',
    min: 1,
    max: 255,
    default: 80,
    description: 'Максимальная амплитуда сигнала'
  },
  zvtime: {
    label: 'Время звука (ms)',
    min: 1000,
    max: 200000,
    default: 95000,
    description: 'Длительность звукового сигнала'
  },
  otime: {
    label: 'Время отклика',
    min: 1,
    max: 100,
    default: 4,
    description: 'Время отклика системы'
  }
}

export function useConfigESP() {
  const { getGlobalSocket } = useWebSocketGlobal()

  // Текущая конфигурация
  const config = ref({
    hz: 14000,
    MaxTime: 140000,
    maxShot: 2,
    maxA: 80,
    zvtime: 95000,
    otime: 4
  })

  // Оригинальная конфигурация (для отслеживания изменений)
  const originalConfig = ref({ ...config.value })

  // Состояние загрузки
  const loading = ref(false)
  const error = ref(null)

  // Состояние сохранения конкретного параметра
  const savingParam = ref(null)

  /**
   * Проверка есть ли несохранённые изменения для параметра
   */
  const hasChanges = (paramName) => {
    return config.value[paramName] !== originalConfig.value[paramName]
  }

  /**
   * Проверка есть ли хоть какие-то несохранённые изменения
   */
  const hasAnyChanges = computed(() => {
    return Object.keys(config.value).some(key => hasChanges(key))
  })

  /**
   * Валидация значения параметра
   */
  const validateParam = (paramName, value) => {
    const schema = ESP_CONFIG_SCHEMA[paramName]
    if (!schema) {
      return { valid: false, error: 'Неизвестный параметр' }
    }

    const numValue = Number(value)

    if (isNaN(numValue)) {
      return { valid: false, error: 'Значение должно быть числом' }
    }

    if (numValue < schema.min || numValue > schema.max) {
      return {
        valid: false,
        error: `Значение должно быть от ${schema.min} до ${schema.max}`
      }
    }

    return { valid: true, error: null }
  }

  /**
   * Загрузка текущих настроек ESP
   */
  const loadConfig = async () => {
    try {
      loading.value = true
      error.value = null

      const socket = await getGlobalSocket()
      logger.info('Загрузка настроек ESP...')

      const response = await socket.sendMessage({ do: 'cfg-esp-get' })

      if (response.do === 'cfg-esp-get' && response.cfg) {
        config.value = { ...response.cfg }
        originalConfig.value = { ...response.cfg }
        logger.success('Настройки ESP загружены', response.cfg)
        return { success: true, config: response.cfg }
      } else {
        throw new Error(response.err || 'Не удалось загрузить настройки')
      }
    } catch (err) {
      error.value = err.message
      logger.error('Ошибка загрузки настроек ESP:', err)
      return { success: false, error: err.message }
    } finally {
      loading.value = false
    }
  }

  /**
   * Сохранение одного параметра
   */
  const saveParam = async (paramName) => {
    try {
      // Валидация
      const validation = validateParam(paramName, config.value[paramName])
      if (!validation.valid) {
        error.value = validation.error
        return { success: false, error: validation.error }
      }

      savingParam.value = paramName
      error.value = null

      const socket = await getGlobalSocket()
      logger.info(`Сохранение параметра ${paramName}=${config.value[paramName]}`)

      const response = await socket.sendMessage({
        do: 'cfg-esp',
        cfg: paramName,
        value: config.value[paramName]
      })

      if (response.do === 'cfg-esp' && response.cfg === paramName) {
        // Успешно сохранено - обновляем оригинал
        originalConfig.value[paramName] = config.value[paramName]
        logger.success(`Параметр ${paramName} сохранён`)
        return { success: true }
      } else if (response.do === 'error') {
        // Ошибка от сервера - откатываем значение
        config.value[paramName] = originalConfig.value[paramName]
        throw new Error(response.message || 'Ошибка сохранения')
      } else {
        throw new Error('Неожиданный ответ сервера')
      }
    } catch (err) {
      // Откатываем значение при ошибке
      config.value[paramName] = originalConfig.value[paramName]
      error.value = err.message
      logger.error(`Ошибка сохранения параметра ${paramName}:`, err)
      return { success: false, error: err.message }
    } finally {
      savingParam.value = null
    }
  }

  /**
   * Сброс параметра к оригинальному значению
   */
  const resetParam = (paramName) => {
    config.value[paramName] = originalConfig.value[paramName]
    logger.info(`Параметр ${paramName} сброшен к ${originalConfig.value[paramName]}`)
  }

  /**
   * Сброс всех параметров
   */
  const resetAll = () => {
    config.value = { ...originalConfig.value }
    logger.info('Все параметры сброшены')
  }

  /**
   * Обновление значения параметра
   */
  const updateParam = (paramName, value) => {
    config.value[paramName] = value
  }

  return {
    // Данные
    config,
    originalConfig,
    configSchema: ESP_CONFIG_SCHEMA,

    // Состояние
    loading,
    error,
    savingParam,
    hasAnyChanges,

    // Методы
    loadConfig,
    saveParam,
    resetParam,
    resetAll,
    updateParam,
    hasChanges,
    validateParam
  }
}