futriix/internal/config/config.go

/*
 * Copyright 2026 Safronov Grigorii
 *
 * Licensed under the CDDL, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 *
 * You may obtain a copy of the License at
 * https://opensource.org/licenses/CDDL-1.0
 */

// Файл: internal/config/config.go
// Назначение: Загрузка и парсинг TOML-конфигурации, валидация параметров,
// предоставление доступа к настройкам кластера, хранилища и REPL.
//
// Данный пакет отвечает за:
//   - Чтение конфигурационного файла в формате TOML
//   - Установку значений по умолчанию для всех параметров
//   - Валидацию корректности настроек
//   - Предоставление типобезопасного доступа к конфигурации через методы-геттеры
//
// ИСПРАВЛЕНО: добавлена секция [metrics] (MetricsConfig) — иначе
// cmd/futriis/main.go не компилируется из-за cfg.Metrics.
//
// ИСПРАВЛЕНО (аудит, кросс-платформенность Linux/OpenIndiana):
//   - BackupConfig дополнен полями IncludeSagaState и EnableIncremental,
//     которые используются BackupScheduler (backup_scheduler.go).
//   - Добавлены геттеры IsIncludeSagaStateEnabled / IsIncrementalEnabled.
//   - В LoadConfig добавлены значения по умолчанию для новых полей.
//   - В ValidateConfigFull добавлена валидация [backup] и [engines].

package config

import (
	"fmt"
	"net"
	"os"
	"strings"
	"time"

	"github.com/BurntSushi/toml"
)

// =============================================================================
// КОНСТАНТЫ ДЛЯ ВАЛИДАЦИИ
// =============================================================================

const (
	// Максимальный размер файла конфигурации (1 MB)
	maxConfigFileSize = 1 * 1024 * 1024
	// Минимальная длина API-ключа
	minAPIKeyLength = 8
)

// allowedLogLevels — допустимые уровни логирования
var allowedLogLevels = map[string]bool{
	"debug": true,
	"info":  true,
	"warn":  true,
	"error": true,
	"fatal": true,
}

// allowedMigrationModes — допустимые режимы миграции
var allowedMigrationModes = map[string]bool{
	"manual":    true,
	"semi_auto": true,
	"auto":      true,
}

// allowedCompressionAlgorithms — допустимые алгоритмы сжатия
var allowedCompressionAlgorithms = map[string]bool{
	"snappy": true,
	"lz4":    true,
	"zstd":   true,
}

// =============================================================================
// ОСНОВНАЯ СТРУКТУРА КОНФИГУРАЦИИ
// =============================================================================

// Config представляет собой корневую структуру конфигурации,
// объединяющую все подсистемы приложения.
// Каждое поле соответствует секции в TOML-файле.
type Config struct {
	Cluster         ClusterConfig         `toml:"cluster"`          // Настройки кластеризации (Raft, узлы)
	Storage         StorageConfig         `toml:"storage"`          // Настройки хранилища (движки, ограничения)
	Repl            ReplConfig            `toml:"repl"`             // Настройки REPL (интерактивной оболочки)
	Log             LogConfig             `toml:"log"`              // Настройки логирования
	API             APIConfig             `toml:"api"`              // Настройки HTTP API
	Replication     ReplicationConfig     `toml:"replication"`      // Настройки репликации
	Plugins         PluginsConfig         `toml:"plugins"`          // Настройки системы плагинов (Lua)
	Compression     CompressionConfig     `toml:"compression"`      // Настройки сжатия данных
	Performance     PerformanceConfig     `toml:"performance"`      // Настройки производительности
	Security        SecurityConfig        `toml:"security"`         // Настройки безопасности (TLS)
	Monitoring      MonitoringConfig      `toml:"monitoring"`       // Настройки мониторинга (метрики, трассировка)
	Recovery        RecoveryConfig        `toml:"recovery"`         // Настройки восстановления после сбоев
	WAL             WALConfig             `toml:"wal"`              // Настройки WAL (Write-Ahead Log)
	MVCC            MVCCConfig            `toml:"mvcc"`             // Настройки MVCC (Multi-Version Concurrency Control)
	Transactions    TransactionsConfig    `toml:"transactions"`     // Настройки транзакций
	Saga            SagaConfig            `toml:"saga"`             // Настройки SAGA оркестратора
	ACL             ACLConfig             `toml:"acl"`              // Настройки ACL (Access Control List)
	ClusterTLS      TLSConfig             `toml:"cluster_tls"`      // Настройки TLS для кластерного взаимодействия
	Backpressure    BackpressureConfig    `toml:"backpressure"`     // Настройки механизма обратного давления
	RuntimeLimits   RuntimeLimitsConfig   `toml:"runtime_limits"`   // Ограничения времени выполнения
	Autoscaling     AutoscalingConfig     `toml:"autoscaling"`      // Настройки автоматического масштабирования
	SchemaMigration SchemaMigrationConfig `toml:"schema_migration"` // Настройки миграции схемы
	Backup          BackupConfig          `toml:"backup"`           // Настройки резервного копирования
	Engines         EnginesConfig         `toml:"engines"`          // Настройки движков хранения
	Migration       MigrationConfig       `toml:"migration"`        // Настройки кросс-датацентровой миграции
	// ИСПРАВЛЕНО: секция [metrics] — Prometheus/Grafana.
	Metrics         MetricsConfig         `toml:"metrics"`
}

// =============================================================================
// КОНФИГУРАЦИЯ МЕТРИК — ИСПРАВЛЕНО
// =============================================================================

// MetricsConfig содержит настройки экспорта метрик в формате Prometheus.
type MetricsConfig struct {
	// Enabled — включает HTTP endpoint /metrics и периодический сбор.
	Enabled bool `toml:"enabled"`
	// CollectIntervalSec — интервал сбора метрик в секундах.
	CollectIntervalSec int `toml:"collect_interval_sec"`
}

// IsMetricsEnabled возвращает флаг включения метрик.
func (m *MetricsConfig) IsMetricsEnabled() bool {
	return m.Enabled
}

// GetCollectInterval возвращает интервал сбора метрик как time.Duration.
// По умолчанию 15 секунд.
func (m *MetricsConfig) GetCollectInterval() time.Duration {
	if m.CollectIntervalSec <= 0 {
		return 15 * time.Second
	}
	return time.Duration(m.CollectIntervalSec) * time.Second
}

// =============================================================================
// КОНФИГУРАЦИЯ КЛАСТЕРА
// =============================================================================

// ClusterConfig содержит настройки для работы в кластерном режиме
// на основе протокола Raft для обеспечения согласованности.
type ClusterConfig struct {
	// Имя кластера - идентификатор для группировки узлов
	Name string `toml:"name"`

	// Сетевые настройки узла
	NodeIP   string `toml:"node_ip"`   // IP-адрес для прослушивания
	NodePort int    `toml:"node_port"` // Порт для клиентских подключений
	RaftPort int    `toml:"raft_port"` // Порт для Raft-коммуникации

	// Настройки Raft
	RaftDataDir string   `toml:"raft_data_dir"` // Директория для хранения Raft-лога
	Bootstrap   bool     `toml:"bootstrap"`     // Является ли узел инициализатором кластера
	Nodes       []string `toml:"nodes"`         // Список адресов других узлов кластера

	// Таймауты Raft (в миллисекундах)
	HeartbeatTimeoutMs int `toml:"heartbeat_timeout_ms"` // Интервал отправки heartbeat
	ElectionTimeoutMs  int `toml:"election_timeout_ms"`  // Таймаут для начала выборов
	CommitTimeoutMs    int `toml:"commit_timeout_ms"`    // Таймаут коммита записей

	// Настройки снэпшотов
	SnapshotIntervalMin int `toml:"snapshot_interval_min"` // Интервал создания снэпшотов (минуты)
	SnapshotThreshold   int `toml:"snapshot_threshold"`    // Количество записей для создания снэпшота

	// Защита от split-brain и восстановление
	SplitBrainPrevention bool `toml:"split_brain_prevention"` // Включить защиту от разделения кластера
	RecoveryTimeoutSec   int  `toml:"recovery_timeout_sec"`   // Таймаут восстановления после сбоя

	// Географические настройки для оптимизации маршрутизации
	Region       string `toml:"region"`        // Регион расположения узла
	PriorityZone int    `toml:"priority_zone"` // Приоритетная зона (0-9, где 9 - наивысший)
}

// =============================================================================
// КОНФИГУРАЦИЯ SAGA ОРКЕСТРАТОРА
// =============================================================================

// SagaConfig содержит настройки отказоустойчивого оркестратора распределённых транзакций.
type SagaConfig struct {
	// Основные настройки
	Enabled          bool   `toml:"enabled"`           // Включить SAGA оркестратор
	CoordinatorCount int    `toml:"coordinator_count"` // Количество координаторов (>= 3 для отказоустойчивости)
	StateDir         string `toml:"state_dir"`         // Директория для хранения состояний SAGA

	// Настройки выполнения
	MaxRetries            int `toml:"max_retries"`              // Максимальное количество попыток выполнения шага
	RetryBackoffMs        int `toml:"retry_backoff_ms"`         // Базовая задержка между повторными попытками (мс)
	SagaTimeoutSec        int `toml:"saga_timeout_sec"`         // Таймаут выполнения SAGA (сек)
	StuckCheckIntervalSec int `toml:"stuck_check_interval_sec"` // Интервал проверки зависших SAGA (сек)

	// Настройки оркестрации
	LeaderElectionIntervalSec int `toml:"leader_election_interval_sec"` // Интервал выбора лидера (сек)
	RecoveryIntervalSec       int `toml:"recovery_interval_sec"`        // Интервал восстановления незавершённых SAGA (сек)
	MetricsIntervalSec        int `toml:"metrics_interval_sec"`         // Интервал сбора метрик (сек)

	// Настройки очистки и кэширования
	CleanupPeriodHours     int `toml:"cleanup_period_hours"`     // Период очистки старых SAGA (часы)
	MaxCacheSize           int `toml:"max_cache_size"`           // Максимальное количество состояний в кэше
	OperationRetentionDays int `toml:"operation_retention_days"` // Время жизни выполненных операций (дни)

	// Настройки производительности
	ChannelBufferSize       int `toml:"channel_buffer_size"`        // Размер буфера каналов
	AsyncRecoveryWorkers    int `toml:"async_recovery_workers"`     // Количество воркеров для асинхронного восстановления
	AsyncRecoveryTimeoutSec int `toml:"async_recovery_timeout_sec"` // Таймаут асинхронного восстановления (сек)

	// Настройки синхронизации с диском
	FsyncEnabled      bool `toml:"fsync_enabled"`        // Принудительная синхронизация с диском
	FsyncMaxRetries   int  `toml:"fsync_max_retries"`    // Количество повторных попыток синхронизации
	FsyncRetryDelayMs int  `toml:"fsync_retry_delay_ms"` // Задержка между повторными попытками (мс)
}

// =============================================================================
// КОНФИГУРАЦИЯ ХРАНИЛИЩА
// =============================================================================

// StorageConfig содержит настройки системы хранения данных.
type StorageConfig struct {
	PageSizeMB                int    `toml:"page_size_mb"`                 // Размер страницы памяти в МБ
	MaxCollections            int    `toml:"max_collections"`              // Максимальное количество коллекций
	MaxDocumentsPerCollection int    `toml:"max_documents_per_collection"` // Макс. документов в коллекции
	DefaultEngine             string `toml:"default_engine"`               // Движок по умолчанию
	EnableCustomEngines       bool   `toml:"enable_custom_engines"`        // Включить пользовательские движки
}

// =============================================================================
// КОНФИГУРАЦИЯ REPL (ИНТЕРАКТИВНАЯ ОБОЛОЧКА)
// =============================================================================

// ReplConfig содержит настройки интерактивной командной оболочки.
type ReplConfig struct {
	PromptColor string `toml:"prompt_color"` // Цвет приглашения ввода
	HistorySize int    `toml:"history_size"` // Размер истории команд
}

// =============================================================================
// КОНФИГУРАЦИЯ ЛОГИРОВАНИЯ
// =============================================================================

// LogConfig содержит настройки системы логирования.
type LogConfig struct {
	LogFile  string `toml:"log_file"`  // Путь к файлу лога (пусто = stdout)
	LogLevel string `toml:"log_level"` // Уровень логирования (debug, info, warn, error)
}

// =============================================================================
// КОНФИГУРАЦИЯ HTTP API
// =============================================================================

// APIConfig содержит настройки HTTP API сервера.
type APIConfig struct {
	Port int `toml:"port"` // Порт для HTTP API
}

// =============================================================================
// КОНФИГУРАЦИЯ РЕПЛИКАЦИИ
// =============================================================================

// ReplicationConfig содержит настройки репликации данных между узлами.
type ReplicationConfig struct {
	Enabled              bool `toml:"enabled"`                // Включена ли репликация
	SyncReplication      bool `toml:"sync_replication"`       // Синхронная репликация
	ReplicationTimeoutMs int  `toml:"replication_timeout_ms"` // Таймаут репликации (мс)
	MaxReplicaLagMs      int  `toml:"max_replica_lag_ms"`     // Максимальное отставание реплики (мс)
}

// =============================================================================
// КОНФИГУРАЦИЯ ПЛАГИНОВ (LUA)
// =============================================================================

// PluginsConfig содержит настройки системы выполнения Lua-скриптов.
type PluginsConfig struct {
	Enabled              bool     `toml:"enabled"`                 // Включена ли поддержка плагинов
	ScriptDir            string   `toml:"script_dir"`              // Директория со скриптами
	AllowList            []string `toml:"allow_list"`              // Белый список разрешенных скриптов
	MaxCPUTimeMs         int      `toml:"max_cpu_time_ms"`         // Макс. время CPU (мс)
	MaxMemoryMB          int      `toml:"max_memory_mb"`           // Макс. память (МБ)
	MaxExecutionTimeSec  int      `toml:"max_execution_time_sec"`  // Макс. время выполнения (сек)
	MaxInstructions      int64    `toml:"max_instructions"`        // Макс. количество инструкций
	HotReloadIntervalSec int      `toml:"hot_reload_interval_sec"` // Интервал горячей перезагрузки
	MaxEventLogSize      int      `toml:"max_event_log_size"`      // Макс. размер лога событий
	LoadTimeoutSec       int      `toml:"load_timeout_sec"`        // Таймаут загрузки скрипта
	MaxLuaStates         int      `toml:"max_lua_states"`          // Макс. количество Lua-состояний
	LuaStateTTLSec       int      `toml:"lua_state_ttl_sec"`       // TTL Lua-состояния
	EnginePluginDir      string   `toml:"engine_plugin_dir"`       // Директория плагинов движков
}

// =============================================================================
// КОНФИГУРАЦИЯ СЖАТИЯ
// =============================================================================

// CompressionConfig содержит настройки сжатия данных.
type CompressionConfig struct {
	Enabled   bool   `toml:"enabled"`   // Включено ли сжатие
	Algorithm string `toml:"algorithm"` // Алгоритм сжатия (snappy, lz4, zstd)
	Level     int    `toml:"level"`     // Уровень сжатия (1-9)
	MinSize   int    `toml:"min_size"`  // Минимальный размер для сжатия (байт)
}

// =============================================================================
// КОНФИГУРАЦИЯ ПРОИЗВОДИТЕЛЬНОСТИ
// =============================================================================

// PerformanceConfig содержит настройки, влияющие на производительность системы.
type PerformanceConfig struct {
	EnablePipeline     bool `toml:"enable_pipeline"`       // Включить конвейерную обработку
	BatchSize          int  `toml:"batch_size"`            // Размер пакета для пакетных операций
	ReadFromFollower   bool `toml:"read_from_follower"`    // Читать с ведомых узлов
	MaxConnections     int  `toml:"max_connections"`       // Максимальное количество соединений
	ReadReplicaDelayMs int  `toml:"read_replica_delay_ms"` // Задержка чтения с реплики (мс)
}

// =============================================================================
// КОНФИГУРАЦИЯ БЕЗОПАСНОСТИ
// =============================================================================

// SecurityConfig содержит настройки безопасности (TLS).
type SecurityConfig struct {
	EnableTLS  bool   `toml:"enable_tls"`  // Включен ли TLS
	CertFile   string `toml:"cert_file"`   // Путь к сертификату
	KeyFile    string `toml:"key_file"`    // Путь к приватному ключу
	CAFile     string `toml:"ca_file"`     // Путь к корневому сертификату CA
	MinVersion string `toml:"min_version"` // Минимальная версия TLS (1.0, 1.1, 1.2, 1.3)
}

// =============================================================================
// КОНФИГУРАЦИЯ МОНИТОРИНГА
// =============================================================================

// MonitoringConfig содержит настройки мониторинга и наблюдаемости.
type MonitoringConfig struct {
	EnableMetrics   bool    `toml:"enable_metrics"`    // Включить сбор метрик
	MetricsPort     int     `toml:"metrics_port"`      // Порт для экспорта метрик (Prometheus)
	EnableTracing   bool    `toml:"enable_tracing"`    // Включить распределённую трассировку
	TraceSampleRate float64 `toml:"trace_sample_rate"` // Частота сэмплирования трассировки (0-1)
}

// =============================================================================
// КОНФИГУРАЦИЯ ВОССТАНОВЛЕНИЯ
// =============================================================================

// RecoveryConfig содержит настройки восстановления после сбоев.
type RecoveryConfig struct {
	AutoRejoin                bool `toml:"auto_rejoin"`                  // Автоматическое переподключение
	MaxRetrySec               int  `toml:"max_retry_sec"`                // Макс. время повторных попыток
	DataReplicationTimeoutSec int  `toml:"data_replication_timeout_sec"` // Таймаут репликации данных
	StaleReadTimeoutSec       int  `toml:"stale_read_timeout_sec"`       // Таймаут устаревшего чтения
}

// =============================================================================
// КОНФИГУРАЦИЯ WAL (WRITE-AHEAD LOG)
// =============================================================================

// WALConfig содержит настройки журнала упреждающей записи.
type WALConfig struct {
	SegmentSizeMB        int  `toml:"segment_size_mb"`        // Размер сегмента WAL (МБ)
	SyncIntervalSec      int  `toml:"sync_interval_sec"`      // Интервал синхронизации на диск
	BatchSize            int  `toml:"batch_size"`             // Размер пакета для записи
	RecoveryWorkers      int  `toml:"recovery_workers"`       // Количество потоков восстановления
	Enabled              bool `toml:"enabled"`                // Включен ли WAL
	AsyncRecovery        bool `toml:"async_recovery"`         // Асинхронное восстановление
	AsyncRecoveryWorkers int  `toml:"async_recovery_workers"` // Потоков асинхронного восстановления
	AsyncRecoveryBuffer  int  `toml:"async_recovery_buffer"`  // Размер буфера асинхронного восстановления
}

// =============================================================================
// КОНФИГУРАЦИЯ MVCC (MULTI-VERSION CONCURRENCY CONTROL)
// =============================================================================

// MVCCConfig содержит настройки механизма многоверсионного контроля параллелизма.
type MVCCConfig struct {
	MaxVersionsPerDoc int `toml:"max_versions_per_doc"` // Макс. версий на документ
	VisibilityMapSize int `toml:"visibility_map_size"`  // Размер карты видимости
	PruneIntervalMin  int `toml:"prune_interval_min"`   // Интервал очистки старых версий (минуты)
	RetentionDays     int `toml:"retention_days"`       // Срок хранения старых версий (дни)
	ReadCacheSize     int `toml:"read_cache_size"`      // Размер кэша чтения
	ReadCacheTTLSec   int `toml:"read_cache_ttl_sec"`   // TTL кэша чтения (секунды)
}

// =============================================================================
// КОНФИГУРАЦИЯ ТРАНЗАКЦИЙ
// =============================================================================

// TransactionsConfig содержит настройки транзакционной подсистемы.
type TransactionsConfig struct {
	DefaultTimeoutSec        int  `toml:"default_timeout_sec"`         // Таймаут транзакции по умолчанию
	DeadlockCheckIntervalSec int  `toml:"deadlock_check_interval_sec"` // Интервал проверки deadlock
	MaxSavepointsPerTx       int  `toml:"max_savepoints_per_tx"`       // Макс. точек сохранения
	Enabled                  bool `toml:"enabled"`                     // Включены ли транзакции
	CheckpointIntervalSec    int  `toml:"checkpoint_interval_sec"`     // Интервал контрольных точек
}

// =============================================================================
// КОНФИГУРАЦИЯ ACL (ACCESS CONTROL LIST)
// =============================================================================

// ACLConfig содержит настройки контроля доступа.
type ACLConfig struct {
	MaxDeniedLogSize       int  `toml:"max_denied_log_size"`       // Макс. размер лога отказов
	TemporaryGrantTTLHours int  `toml:"temporary_grant_ttl_hours"` // TTL временных прав (часы)
	EnableRoleHierarchy    bool `toml:"enable_role_hierarchy"`     // Иерархия ролей
	CacheTTLSec            int  `toml:"cache_ttl_sec"`             // TTL кэша ACL (сек)
}

// =============================================================================
// КОНФИГУРАЦИЯ TLS ДЛЯ КЛАСТЕРА
// =============================================================================

// TLSConfig содержит настройки TLS для кластерного взаимодействия.
type TLSConfig struct {
	Enabled         bool   `toml:"enabled"`           // Включен ли TLS
	CertFile        string `toml:"cert_file"`         // Путь к сертификату
	KeyFile         string `toml:"key_file"`          // Путь к приватному ключу
	CAFile          string `toml:"ca_file"`           // Путь к корневому сертификату CA
	MinVersion      string `toml:"min_version"`       // Минимальная версия TLS
	MutualAuth      bool   `toml:"mutual_auth"`       // Взаимная аутентификация
	KeyRotationDays int    `toml:"key_rotation_days"` // Интервал ротации ключей
	AutoGenerate    bool   `toml:"auto_generate"`     // Автоматическая генерация сертификатов
}

// =============================================================================
// КОНФИГУРАЦИЯ ОБРАТНОГО ДАВЛЕНИЯ (BACKPRESSURE)
// =============================================================================

// BackpressureConfig содержит настройки механизма обратного давления.
type BackpressureConfig struct {
	Enabled             bool    `toml:"enabled"`              // Включен ли механизм
	CPUThreshold        float64 `toml:"cpu_threshold"`        // Порог CPU (0-1)
	MemoryThreshold     float64 `toml:"memory_threshold"`     // Порог памяти (0-1)
	QueueSizeThreshold  int     `toml:"queue_size_threshold"` // Порог размера очереди
	ConnectionThreshold int     `toml:"connection_threshold"` // Порог количества соединений
	CheckIntervalMs     int     `toml:"check_interval_ms"`    // Интервал проверки (мс)
	LowDelayMs          int64   `toml:"low_delay_ms"`         // Задержка для низкой нагрузки (мс)
	MediumRejectProb    uint32  `toml:"medium_reject_prob"`   // Вероятность отказа при средней нагрузке (%)
	HighRejectProb      uint32  `toml:"high_reject_prob"`     // Вероятность отказа при высокой нагрузке (%)
}

// =============================================================================
// КОНФИГУРАЦИЯ ОГРАНИЧЕНИЙ ВРЕМЕНИ ВЫПОЛНЕНИЯ
// =============================================================================

// RuntimeLimitsConfig содержит глобальные ограничения для защиты от недобросовестных запросов.
type RuntimeLimitsConfig struct {
	Enabled              bool  `toml:"enabled"`                  // Включены ли ограничения
	GlobalMaxDocSizeMB   int   `toml:"global_max_doc_size_mb"`   // Макс. размер документа (МБ)
	GlobalMaxCollSizeMB  int64 `toml:"global_max_coll_size_mb"`  // Макс. размер коллекции (МБ)
	GlobalMaxDocsPerColl int64 `toml:"global_max_docs_per_coll"` // Макс. документов в коллекции
}

// =============================================================================
// КОНФИГУРАЦИЯ АВТОМАСШТАБИРОВАНИЯ
// =============================================================================

// AutoscalingConfig содержит настройки автоматического масштабирования кластера.
type AutoscalingConfig struct {
	Enabled               bool    `toml:"enabled"`                 // Включено ли автомасштабирование
	MinNodes              int     `toml:"min_nodes"`               // Минимальное количество узлов
	MaxNodes              int     `toml:"max_nodes"`               // Максимальное количество узлов
	ScaleUpThreshold      float64 `toml:"scale_up_threshold"`      // Порог для увеличения (0-1)
	ScaleDownThreshold    float64 `toml:"scale_down_threshold"`    // Порог для уменьшения (0-1)
	ScaleUpCooldownSec    int     `toml:"scale_up_cooldown_sec"`   // Задержка перед масштабированием вверх
	ScaleDownCooldownSec  int     `toml:"scale_down_cooldown_sec"` // Задержка перед масштабированием вниз
	EvaluationIntervalSec int     `toml:"evaluation_interval_sec"` // Интервал оценки нагрузки
	PredictiveEnabled     bool    `toml:"predictive_enabled"`      // Прогнозирующее масштабирование
	MaxScaleUpNodes       int     `toml:"max_scale_up_nodes"`      // Макс. узлов при масштабировании вверх
	MaxScaleDownNodes     int     `toml:"max_scale_down_nodes"`    // Макс. узлов при масштабировании вниз
}

// =============================================================================
// КОНФИГУРАЦИЯ МИГРАЦИИ СХЕМЫ
// =============================================================================

// SchemaMigrationConfig содержит настройки миграции схемы данных.
type SchemaMigrationConfig struct {
	Enabled       bool   `toml:"enabled"`        // Включена ли миграция
	MigrationDir  string `toml:"migration_dir"`  // Директория с миграциями
	AutoMigrate   bool   `toml:"auto_migrate"`   // Автоматическая миграция при старте
	TargetVersion string `toml:"target_version"` // Целевая версия схемы
}

// =============================================================================
// КОНФИГУРАЦИЯ РЕЗЕРВНОГО КОПИРОВАНИЯ
// =============================================================================
//
// ИСПРАВЛЕНО: добавлены поля IncludeSagaState и EnableIncremental,
// которые используются BackupScheduler (backup_scheduler.go):
//   - IncludeSagaState — включает состояние активных SAGA в бэкап.
//   - EnableIncremental — разрешает создание инкрементальных бэкапов.
// Без этих полей TOML-ключи include_saga_state / enable_incremental
// игнорировались, что приводило к неполному бэкапу.

// BackupConfig содержит настройки резервного копирования.
type BackupConfig struct {
	Enabled         bool   `toml:"enabled"`          // Включено ли резервное копирование
	BackupDir       string `toml:"backup_dir"`       // Директория для бэкапов
	MaxConcurrent   int    `toml:"max_concurrent"`   // Макс. параллельных бэкапов
	CompressEnabled bool   `toml:"compress_enabled"` // Сжатие бэкапов
	RetentionDays   int    `toml:"retention_days"`   // Срок хранения бэкапов (дни)

	// Дополнительные поля, используемые BackupScheduler.
	IncludeSagaState  bool `toml:"include_saga_state"` // Включать состояние SAGA в бэкап
	EnableIncremental bool `toml:"enable_incremental"` // Разрешить инкрементальные бэкапы
}

// =============================================================================
// КОНФИГУРАЦИЯ ДВИЖКОВ ХРАНЕНИЯ
// =============================================================================

// EnginesConfig содержит настройки всех движков хранения данных.
type EnginesConfig struct {
	Row      EngineConfig `toml:"row"`      // Строчный движок (по умолчанию)
	Columnar EngineConfig `toml:"columnar"` // Колоночный движок (аналитика)
	Document EngineConfig `toml:"document"` // Документоориентированный движок
	KV       EngineConfig `toml:"kv"`       // Key-Value движок
	TS       EngineConfig `toml:"ts"`       // Time-Series движок (временные ряды)
	Graph    EngineConfig `toml:"graph"`    // Графовый движок
}

// EngineConfig содержит настройки отдельного движка хранения.
type EngineConfig struct {
	Enabled     bool                   `toml:"enabled"`     // Включен ли движок
	Description string                 `toml:"description"` // Описание движка
	Config      map[string]interface{} `toml:"config"`      // Дополнительные параметры движка
}

// =============================================================================
// КОНФИГУРАЦИЯ КРОСС-ДАТАЦЕНТРОВОЙ МИГРАЦИИ
// =============================================================================

// MigrationConfig представляет конфигурацию кросс-датацентровой миграции
type MigrationConfig struct {
	Enabled    bool               `toml:"enabled"`
	Mode       string             `toml:"mode"` // manual, semi_auto, auto
	Source     *DatacenterConfig  `toml:"source"`
	Target     *DatacenterConfig  `toml:"target"`
	Settings   *MigrationSettings `toml:"settings"`
	Delta      *DeltaSyncConfig   `toml:"delta"`
	Validation *ValidationConfig  `toml:"validation"`
}

// DatacenterConfig представляет конфигурацию датацентра
type DatacenterConfig struct {
	Name       string `toml:"name"`
	Endpoint   string `toml:"endpoint"`
	APIKey     string `toml:"api_key"`
	TimeoutSec int    `toml:"timeout_sec"`
}

// MigrationSettings представляет настройки миграции
type MigrationSettings struct {
	BatchSize             int      `toml:"batch_size"`
	Workers               int      `toml:"workers"`
	Compression           string   `toml:"compression"`
	ResumeEnabled         bool     `toml:"resume_enabled"`
	CheckpointIntervalSec int      `toml:"checkpoint_interval_sec"`
	MaxRetries            int      `toml:"max_retries"`
	RetryBackoffSec       int      `toml:"retry_backoff_sec"`
	Collections           []string `toml:"collections"`
	ExcludeCollections    []string `toml:"exclude_collections"`
}

// DeltaSyncConfig представляет конфигурацию дельта-синхронизации
type DeltaSyncConfig struct {
	Enabled     bool `toml:"enabled"`
	IntervalSec int  `toml:"interval_sec"`
	MaxLagSec   int  `toml:"max_lag_sec"`
}

// ValidationConfig представляет конфигурацию валидации
type ValidationConfig struct {
	Enabled       bool `toml:"enabled"`
	SamplePercent int  `toml:"sample_percent"`
	MaxErrors     int  `toml:"max_errors"`
}

// =============================================================================
// ВСПОМОГАТЕЛЬНЫЕ СТРУКТУРЫ
// =============================================================================

// ValidationResult содержит результаты валидации конфигурации.
type ValidationResult struct {
	Valid    bool    // Корректна ли конфигурация
	Errors   []error // Критические ошибки
	Warnings []error // Предупреждения (некритичные)
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ SagaConfig
// =============================================================================

// IsSagaEnabled возвращает флаг включения SAGA оркестратора.
func (s *SagaConfig) IsSagaEnabled() bool { return s.Enabled }

// GetCoordinatorCount возвращает количество координаторов.
func (s *SagaConfig) GetCoordinatorCount() int {
	if s.CoordinatorCount < 1 {
		return 3
	}
	return s.CoordinatorCount
}

// GetStateDir возвращает директорию для хранения состояний SAGA.
func (s *SagaConfig) GetStateDir() string {
	if s.StateDir == "" {
		return "saga_states"
	}
	return s.StateDir
}

// GetMaxRetries возвращает максимальное количество попыток выполнения шага.
func (s *SagaConfig) GetMaxRetries() int {
	if s.MaxRetries <= 0 {
		return 5
	}
	return s.MaxRetries
}

// GetRetryBackoff возвращает базовую задержку между повторными попытками.
func (s *SagaConfig) GetRetryBackoff() time.Duration {
	if s.RetryBackoffMs <= 0 {
		return 100 * time.Millisecond
	}
	return time.Duration(s.RetryBackoffMs) * time.Millisecond
}

// GetSagaTimeout возвращает таймаут выполнения SAGA.
func (s *SagaConfig) GetSagaTimeout() time.Duration {
	if s.SagaTimeoutSec <= 0 {
		return 300 * time.Second
	}
	return time.Duration(s.SagaTimeoutSec) * time.Second
}

// GetStuckCheckInterval возвращает интервал проверки зависших SAGA.
func (s *SagaConfig) GetStuckCheckInterval() time.Duration {
	if s.StuckCheckIntervalSec <= 0 {
		return 10 * time.Second
	}
	return time.Duration(s.StuckCheckIntervalSec) * time.Second
}

// GetLeaderElectionInterval возвращает интервал выбора лидера.
func (s *SagaConfig) GetLeaderElectionInterval() time.Duration {
	if s.LeaderElectionIntervalSec <= 0 {
		return 5 * time.Second
	}
	return time.Duration(s.LeaderElectionIntervalSec) * time.Second
}

// GetRecoveryInterval возвращает интервал восстановления незавершённых SAGA.
func (s *SagaConfig) GetRecoveryInterval() time.Duration {
	if s.RecoveryIntervalSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(s.RecoveryIntervalSec) * time.Second
}

// GetMetricsInterval возвращает интервал сбора метрик.
func (s *SagaConfig) GetMetricsInterval() time.Duration {
	if s.MetricsIntervalSec <= 0 {
		return 60 * time.Second
	}
	return time.Duration(s.MetricsIntervalSec) * time.Second
}

// GetCleanupPeriod возвращает период очистки старых SAGA.
func (s *SagaConfig) GetCleanupPeriod() time.Duration {
	if s.CleanupPeriodHours <= 0 {
		return 24 * time.Hour
	}
	return time.Duration(s.CleanupPeriodHours) * time.Hour
}

// GetMaxCacheSize возвращает максимальное количество состояний в кэше.
func (s *SagaConfig) GetMaxCacheSize() int {
	if s.MaxCacheSize <= 0 {
		return 10000
	}
	return s.MaxCacheSize
}

// GetOperationRetentionDuration возвращает время жизни выполненных операций.
func (s *SagaConfig) GetOperationRetentionDuration() time.Duration {
	if s.OperationRetentionDays <= 0 {
		return 7 * 24 * time.Hour
	}
	return time.Duration(s.OperationRetentionDays) * 24 * time.Hour
}

// GetChannelBufferSize возвращает размер буфера каналов.
func (s *SagaConfig) GetChannelBufferSize() int {
	if s.ChannelBufferSize <= 0 {
		return 10000
	}
	return s.ChannelBufferSize
}

// GetAsyncRecoveryWorkers возвращает количество воркеров для асинхронного восстановления.
func (s *SagaConfig) GetAsyncRecoveryWorkers() int {
	if s.AsyncRecoveryWorkers <= 0 {
		return 4
	}
	return s.AsyncRecoveryWorkers
}

// GetAsyncRecoveryTimeout возвращает таймаут асинхронного восстановления.
func (s *SagaConfig) GetAsyncRecoveryTimeout() time.Duration {
	if s.AsyncRecoveryTimeoutSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(s.AsyncRecoveryTimeoutSec) * time.Second
}

// IsFsyncEnabled возвращает флаг принудительной синхронизации с диском.
func (s *SagaConfig) IsFsyncEnabled() bool { return s.FsyncEnabled }

// GetFsyncMaxRetries возвращает количество повторных попыток синхронизации.
func (s *SagaConfig) GetFsyncMaxRetries() int {
	if s.FsyncMaxRetries <= 0 {
		return 3
	}
	return s.FsyncMaxRetries
}

// GetFsyncRetryDelay возвращает задержку между повторными попытками синхронизации.
func (s *SagaConfig) GetFsyncRetryDelay() time.Duration {
	if s.FsyncRetryDelayMs <= 0 {
		return 100 * time.Millisecond
	}
	return time.Duration(s.FsyncRetryDelayMs) * time.Millisecond
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ ReplicationConfig
// =============================================================================

// GetReplicationTimeout возвращает таймаут репликации как time.Duration.
func (r *ReplicationConfig) GetReplicationTimeout() time.Duration {
	if r.ReplicationTimeoutMs <= 0 {
		return 5 * time.Second
	}
	return time.Duration(r.ReplicationTimeoutMs) * time.Millisecond
}

// IsReplicationEnabled возвращает флаг включения репликации.
func (r *ReplicationConfig) IsReplicationEnabled() bool { return r.Enabled }

// IsSyncReplicationEnabled возвращает флаг синхронной репликации.
func (r *ReplicationConfig) IsSyncReplicationEnabled() bool { return r.SyncReplication }

// GetMaxReplicaLag возвращает максимальное допустимое отставание реплики.
func (r *ReplicationConfig) GetMaxReplicaLag() time.Duration {
	if r.MaxReplicaLagMs <= 0 {
		return 5 * time.Second
	}
	return time.Duration(r.MaxReplicaLagMs) * time.Millisecond
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ ClusterConfig
// =============================================================================

// GetHeartbeatTimeout возвращает таймаут heartbeat-сообщений.
func (c *ClusterConfig) GetHeartbeatTimeout() time.Duration {
	if c.HeartbeatTimeoutMs <= 0 {
		return 1000 * time.Millisecond
	}
	return time.Duration(c.HeartbeatTimeoutMs) * time.Millisecond
}

// GetElectionTimeout возвращает таймаут для начала выборов лидера.
func (c *ClusterConfig) GetElectionTimeout() time.Duration {
	if c.ElectionTimeoutMs <= 0 {
		return 1000 * time.Millisecond
	}
	return time.Duration(c.ElectionTimeoutMs) * time.Millisecond
}

// GetCommitTimeout возвращает таймаут коммита записей.
func (c *ClusterConfig) GetCommitTimeout() time.Duration {
	if c.CommitTimeoutMs <= 0 {
		return 500 * time.Millisecond
	}
	return time.Duration(c.CommitTimeoutMs) * time.Millisecond
}

// GetSnapshotInterval возвращает интервал создания снэпшотов.
func (c *ClusterConfig) GetSnapshotInterval() time.Duration {
	if c.SnapshotIntervalMin <= 0 {
		return 30 * time.Minute
	}
	return time.Duration(c.SnapshotIntervalMin) * time.Minute
}

// GetSnapshotThreshold возвращает порог количества записей для создания снэпшота.
func (c *ClusterConfig) GetSnapshotThreshold() uint64 {
	if c.SnapshotThreshold <= 0 {
		return 1000
	}
	return uint64(c.SnapshotThreshold)
}

// IsSplitBrainPreventionEnabled возвращает флаг защиты от split-brain.
func (c *ClusterConfig) IsSplitBrainPreventionEnabled() bool { return c.SplitBrainPrevention }

// GetRecoveryTimeout возвращает таймаут восстановления после сбоя.
func (c *ClusterConfig) GetRecoveryTimeout() time.Duration {
	if c.RecoveryTimeoutSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(c.RecoveryTimeoutSec) * time.Second
}

// GetRegion возвращает регион узла.
func (c *ClusterConfig) GetRegion() string {
	if c.Region == "" {
		return "default"
	}
	return c.Region
}

// GetPriorityZone возвращает приоритетную зону узла.
func (c *ClusterConfig) GetPriorityZone() int {
	if c.PriorityZone < 0 {
		return 0
	}
	if c.PriorityZone > 9 {
		return 9
	}
	return c.PriorityZone
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ PluginsConfig
// =============================================================================

// GetMaxCPUTime возвращает максимальное время CPU для выполнения скрипта.
func (p *PluginsConfig) GetMaxCPUTime() time.Duration {
	if p.MaxCPUTimeMs <= 0 {
		return 100 * time.Millisecond
	}
	return time.Duration(p.MaxCPUTimeMs) * time.Millisecond
}

// GetMaxMemory возвращает максимальный объем памяти для скрипта в байтах.
func (p *PluginsConfig) GetMaxMemory() int64 {
	if p.MaxMemoryMB <= 0 {
		return 50 * 1024 * 1024
	}
	return int64(p.MaxMemoryMB) * 1024 * 1024
}

// GetMaxExecutionTime возвращает максимальное время выполнения скрипта.
func (p *PluginsConfig) GetMaxExecutionTime() time.Duration {
	if p.MaxExecutionTimeSec <= 0 {
		return 5 * time.Second
	}
	return time.Duration(p.MaxExecutionTimeSec) * time.Second
}

// GetMaxInstructions возвращает максимальное количество инструкций для скрипта.
func (p *PluginsConfig) GetMaxInstructions() int64 {
	if p.MaxInstructions <= 0 {
		return 1000000
	}
	return p.MaxInstructions
}

// GetHotReloadInterval возвращает интервал горячей перезагрузки скриптов.
func (p *PluginsConfig) GetHotReloadInterval() time.Duration {
	if p.HotReloadIntervalSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(p.HotReloadIntervalSec) * time.Second
}

// GetMaxEventLogSize возвращает максимальный размер лога событий.
func (p *PluginsConfig) GetMaxEventLogSize() int {
	if p.MaxEventLogSize <= 0 {
		return 1000
	}
	return p.MaxEventLogSize
}

// GetLoadTimeout возвращает таймаут загрузки скрипта.
func (p *PluginsConfig) GetLoadTimeout() time.Duration {
	if p.LoadTimeoutSec <= 0 {
		return 10 * time.Second
	}
	return time.Duration(p.LoadTimeoutSec) * time.Second
}

// GetMaxLuaStates возвращает максимальное количество Lua-состояний.
func (p *PluginsConfig) GetMaxLuaStates() int {
	if p.MaxLuaStates <= 0 {
		return 100
	}
	return p.MaxLuaStates
}

// GetLuaStateTTL возвращает время жизни Lua-состояния.
func (p *PluginsConfig) GetLuaStateTTL() time.Duration {
	if p.LuaStateTTLSec <= 0 {
		return 10 * time.Minute
	}
	return time.Duration(p.LuaStateTTLSec) * time.Second
}

// GetEnginePluginDir возвращает директорию с плагинами движков.
func (p *PluginsConfig) GetEnginePluginDir() string {
	if p.EnginePluginDir == "" {
		return "engines"
	}
	return p.EnginePluginDir
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ WALConfig
// =============================================================================

// GetSegmentSize возвращает размер сегмента WAL в байтах.
func (w *WALConfig) GetSegmentSize() int64 {
	if w.SegmentSizeMB <= 0 {
		return 64 * 1024 * 1024
	}
	return int64(w.SegmentSizeMB) * 1024 * 1024
}

// GetSyncInterval возвращает интервал синхронизации WAL с диском.
func (w *WALConfig) GetSyncInterval() time.Duration {
	if w.SyncIntervalSec <= 0 {
		return 5 * time.Second
	}
	return time.Duration(w.SyncIntervalSec) * time.Second
}

// GetBatchSize возвращает размер пакета для записи в WAL.
func (w *WALConfig) GetBatchSize() int {
	if w.BatchSize <= 0 {
		return 100
	}
	return w.BatchSize
}

// GetRecoveryWorkers возвращает количество потоков для восстановления из WAL.
func (w *WALConfig) GetRecoveryWorkers() int {
	if w.RecoveryWorkers <= 0 {
		return 4
	}
	return w.RecoveryWorkers
}

// IsWALEnabled возвращает флаг включения WAL.
func (w *WALConfig) IsWALEnabled() bool { return w.Enabled }

// IsAsyncRecoveryEnabled возвращает флаг асинхронного восстановления.
func (w *WALConfig) IsAsyncRecoveryEnabled() bool { return w.AsyncRecovery }

// GetAsyncRecoveryWorkers возвращает количество потоков асинхронного восстановления.
func (w *WALConfig) GetAsyncRecoveryWorkers() int {
	if w.AsyncRecoveryWorkers <= 0 {
		return 4
	}
	return w.AsyncRecoveryWorkers
}

// GetAsyncRecoveryBuffer возвращает размер буфера асинхронного восстановления.
func (w *WALConfig) GetAsyncRecoveryBuffer() int {
	if w.AsyncRecoveryBuffer <= 0 {
		return 10000
	}
	return w.AsyncRecoveryBuffer
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ MVCCConfig
// =============================================================================

// GetMaxVersionsPerDoc возвращает максимальное количество версий на документ.
func (m *MVCCConfig) GetMaxVersionsPerDoc() int {
	if m.MaxVersionsPerDoc <= 0 {
		return 10
	}
	return m.MaxVersionsPerDoc
}

// GetVisibilityMapSize возвращает размер карты видимости.
func (m *MVCCConfig) GetVisibilityMapSize() int {
	if m.VisibilityMapSize <= 0 {
		return 1024 * 1024
	}
	return m.VisibilityMapSize
}

// GetPruneInterval возвращает интервал очистки старых версий.
func (m *MVCCConfig) GetPruneInterval() time.Duration {
	if m.PruneIntervalMin <= 0 {
		return 5 * time.Minute
	}
	return time.Duration(m.PruneIntervalMin) * time.Minute
}

// GetRetentionDays возвращает срок хранения старых версий в днях.
func (m *MVCCConfig) GetRetentionDays() int {
	if m.RetentionDays <= 0 {
		return 7
	}
	return m.RetentionDays
}

// GetReadCacheSize возвращает размер кэша чтения.
func (m *MVCCConfig) GetReadCacheSize() int {
	if m.ReadCacheSize <= 0 {
		return 10000
	}
	return m.ReadCacheSize
}

// GetReadCacheTTL возвращает TTL кэша чтения.
func (m *MVCCConfig) GetReadCacheTTL() time.Duration {
	if m.ReadCacheTTLSec <= 0 {
		return 300 * time.Second
	}
	return time.Duration(m.ReadCacheTTLSec) * time.Second
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ TransactionsConfig
// =============================================================================

// GetDefaultTimeout возвращает таймаут транзакции по умолчанию.
func (t *TransactionsConfig) GetDefaultTimeout() time.Duration {
	if t.DefaultTimeoutSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(t.DefaultTimeoutSec) * time.Second
}

// GetDeadlockCheckInterval возвращает интервал проверки взаимоблокировок.
func (t *TransactionsConfig) GetDeadlockCheckInterval() time.Duration {
	if t.DeadlockCheckIntervalSec <= 0 {
		return 1 * time.Second
	}
	return time.Duration(t.DeadlockCheckIntervalSec) * time.Second
}

// GetMaxSavepointsPerTx возвращает максимальное количество точек сохранения.
func (t *TransactionsConfig) GetMaxSavepointsPerTx() int {
	if t.MaxSavepointsPerTx <= 0 {
		return 100
	}
	return t.MaxSavepointsPerTx
}

// IsTransactionsEnabled возвращает флаг включения транзакций.
func (t *TransactionsConfig) IsTransactionsEnabled() bool { return t.Enabled }

// GetCheckpointInterval возвращает интервал контрольных точек в секундах.
func (t *TransactionsConfig) GetCheckpointInterval() int64 {
	if t.CheckpointIntervalSec <= 0 {
		return 300
	}
	return int64(t.CheckpointIntervalSec)
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ ACLConfig
// =============================================================================

// GetMaxDeniedLogSize возвращает максимальный размер лога отказов в доступе.
func (a *ACLConfig) GetMaxDeniedLogSize() int {
	if a.MaxDeniedLogSize <= 0 {
		return 10000
	}
	return a.MaxDeniedLogSize
}

// GetTemporaryGrantTTL возвращает TTL временных прав доступа.
func (a *ACLConfig) GetTemporaryGrantTTL() time.Duration {
	if a.TemporaryGrantTTLHours <= 0 {
		return 24 * time.Hour
	}
	return time.Duration(a.TemporaryGrantTTLHours) * time.Hour
}

// IsRoleHierarchyEnabled возвращает флаг включения иерархии ролей.
func (a *ACLConfig) IsRoleHierarchyEnabled() bool { return a.EnableRoleHierarchy }

// GetCacheTTL возвращает TTL кэша ACL.
func (a *ACLConfig) GetCacheTTL() time.Duration {
	if a.CacheTTLSec <= 0 {
		return 60 * time.Second
	}
	return time.Duration(a.CacheTTLSec) * time.Second
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ TLSConfig
// =============================================================================

// GetTLSMinVersion возвращает минимальную версию TLS как строку.
func (t *TLSConfig) GetTLSMinVersion() string {
	if t.MinVersion == "" {
		return "1.2"
	}
	return t.MinVersion
}

// IsTLSEnabled возвращает флаг включения TLS.
func (t *TLSConfig) IsTLSEnabled() bool { return t.Enabled }

// IsMutualAuthEnabled возвращает флаг взаимной аутентификации.
func (t *TLSConfig) IsMutualAuthEnabled() bool { return t.MutualAuth }

// GetKeyRotationDays возвращает интервал ротации ключей в днях.
func (t *TLSConfig) GetKeyRotationDays() int {
	if t.KeyRotationDays <= 0 {
		return 30
	}
	return t.KeyRotationDays
}

// IsAutoGenerateEnabled возвращает флаг автоматической генерации сертификатов.
func (t *TLSConfig) IsAutoGenerateEnabled() bool { return t.AutoGenerate }

// =============================================================================
// ГЕТТЕРЫ ДЛЯ BackpressureConfig
// =============================================================================

// IsBackpressureEnabled возвращает флаг включения механизма обратного давления.
func (b *BackpressureConfig) IsBackpressureEnabled() bool { return b.Enabled }

// GetCPUThreshold возвращает порог загрузки CPU.
func (b *BackpressureConfig) GetCPUThreshold() float64 {
	if b.CPUThreshold <= 0 {
		return 0.8
	}
	if b.CPUThreshold > 1.0 {
		return 1.0
	}
	return b.CPUThreshold
}

// GetMemoryThreshold возвращает порог использования памяти.
func (b *BackpressureConfig) GetMemoryThreshold() float64 {
	if b.MemoryThreshold <= 0 {
		return 0.85
	}
	if b.MemoryThreshold > 1.0 {
		return 1.0
	}
	return b.MemoryThreshold
}

// GetQueueSizeThreshold возвращает порог размера очереди.
func (b *BackpressureConfig) GetQueueSizeThreshold() int {
	if b.QueueSizeThreshold <= 0 {
		return 10000
	}
	return b.QueueSizeThreshold
}

// GetConnectionThreshold возвращает порог количества соединений.
func (b *BackpressureConfig) GetConnectionThreshold() int {
	if b.ConnectionThreshold <= 0 {
		return 5000
	}
	return b.ConnectionThreshold
}

// GetCheckInterval возвращает интервал проверки нагрузки.
func (b *BackpressureConfig) GetCheckInterval() time.Duration {
	if b.CheckIntervalMs <= 0 {
		return 1 * time.Second
	}
	return time.Duration(b.CheckIntervalMs) * time.Millisecond
}

// GetLowDelay возвращает задержку при низкой нагрузке.
func (b *BackpressureConfig) GetLowDelay() time.Duration {
	if b.LowDelayMs <= 0 {
		return 100 * time.Millisecond
	}
	return time.Duration(b.LowDelayMs) * time.Millisecond
}

// GetMediumRejectProb возвращает вероятность отказа при средней нагрузке.
func (b *BackpressureConfig) GetMediumRejectProb() uint32 {
	if b.MediumRejectProb > 100 {
		return 100
	}
	return b.MediumRejectProb
}

// GetHighRejectProb возвращает вероятность отказа при высокой нагрузке.
func (b *BackpressureConfig) GetHighRejectProb() uint32 {
	if b.HighRejectProb > 100 {
		return 100
	}
	return b.HighRejectProb
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ RuntimeLimitsConfig
// =============================================================================

// IsRuntimeLimitsEnabled возвращает флаг включения ограничений времени выполнения.
func (r *RuntimeLimitsConfig) IsRuntimeLimitsEnabled() bool { return r.Enabled }

// GetGlobalMaxDocSizeMB возвращает максимальный размер документа в МБ.
func (r *RuntimeLimitsConfig) GetGlobalMaxDocSizeMB() int {
	if r.GlobalMaxDocSizeMB <= 0 {
		return 16
	}
	return r.GlobalMaxDocSizeMB
}

// GetGlobalMaxCollSizeMB возвращает максимальный размер коллекции в МБ.
func (r *RuntimeLimitsConfig) GetGlobalMaxCollSizeMB() int64 {
	if r.GlobalMaxCollSizeMB <= 0 {
		return 10240
	}
	return r.GlobalMaxCollSizeMB
}

// GetGlobalMaxDocsPerColl возвращает максимальное количество документов в коллекции.
func (r *RuntimeLimitsConfig) GetGlobalMaxDocsPerColl() int64 {
	if r.GlobalMaxDocsPerColl <= 0 {
		return 10000000
	}
	return r.GlobalMaxDocsPerColl
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ AutoscalingConfig
// =============================================================================

// IsAutoscalingEnabled возвращает флаг включения автомасштабирования.
func (a *AutoscalingConfig) IsAutoscalingEnabled() bool { return a.Enabled }

// GetMinNodes возвращает минимальное количество узлов.
func (a *AutoscalingConfig) GetMinNodes() int {
	if a.MinNodes <= 0 {
		return 1
	}
	return a.MinNodes
}

// GetMaxNodes возвращает максимальное количество узлов.
func (a *AutoscalingConfig) GetMaxNodes() int {
	if a.MaxNodes <= 0 {
		return 10
	}
	return a.MaxNodes
}

// GetScaleUpThreshold возвращает порог для масштабирования вверх.
func (a *AutoscalingConfig) GetScaleUpThreshold() float64 {
	if a.ScaleUpThreshold <= 0 {
		return 0.75
	}
	if a.ScaleUpThreshold > 1.0 {
		return 1.0
	}
	return a.ScaleUpThreshold
}

// GetScaleDownThreshold возвращает порог для масштабирования вниз.
func (a *AutoscalingConfig) GetScaleDownThreshold() float64 {
	if a.ScaleDownThreshold <= 0 {
		return 0.30
	}
	return a.ScaleDownThreshold
}

// GetScaleUpCooldown возвращает задержку перед масштабированием вверх.
func (a *AutoscalingConfig) GetScaleUpCooldown() time.Duration {
	if a.ScaleUpCooldownSec <= 0 {
		return 5 * time.Minute
	}
	return time.Duration(a.ScaleUpCooldownSec) * time.Second
}

// GetScaleDownCooldown возвращает задержку перед масштабированием вниз.
func (a *AutoscalingConfig) GetScaleDownCooldown() time.Duration {
	if a.ScaleDownCooldownSec <= 0 {
		return 10 * time.Minute
	}
	return time.Duration(a.ScaleDownCooldownSec) * time.Second
}

// GetEvaluationInterval возвращает интервал оценки нагрузки.
func (a *AutoscalingConfig) GetEvaluationInterval() time.Duration {
	if a.EvaluationIntervalSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(a.EvaluationIntervalSec) * time.Second
}

// IsPredictiveEnabled возвращает флаг прогнозирующего масштабирования.
func (a *AutoscalingConfig) IsPredictiveEnabled() bool { return a.PredictiveEnabled }

// GetMaxScaleUpNodes возвращает максимальное количество узлов для масштабирования вверх.
func (a *AutoscalingConfig) GetMaxScaleUpNodes() int {
	if a.MaxScaleUpNodes <= 0 {
		return 3
	}
	return a.MaxScaleUpNodes
}

// GetMaxScaleDownNodes возвращает максимальное количество узлов для масштабирования вниз.
func (a *AutoscalingConfig) GetMaxScaleDownNodes() int {
	if a.MaxScaleDownNodes <= 0 {
		return 2
	}
	return a.MaxScaleDownNodes
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ SchemaMigrationConfig
// =============================================================================

// IsSchemaMigrationEnabled возвращает флаг включения миграции схемы.
func (s *SchemaMigrationConfig) IsSchemaMigrationEnabled() bool { return s.Enabled }

// GetMigrationDir возвращает директорию с миграциями.
func (s *SchemaMigrationConfig) GetMigrationDir() string {
	if s.MigrationDir == "" {
		return "migrations"
	}
	return s.MigrationDir
}

// IsAutoMigrateEnabled возвращает флаг автоматической миграции при старте.
func (s *SchemaMigrationConfig) IsAutoMigrateEnabled() bool { return s.AutoMigrate }

// GetTargetVersion возвращает целевую версию схемы.
func (s *SchemaMigrationConfig) GetTargetVersion() string {
	if s.TargetVersion == "" {
		return "latest"
	}
	return s.TargetVersion
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ BackupConfig
// =============================================================================

// IsBackupEnabled возвращает флаг включения резервного копирования.
func (b *BackupConfig) IsBackupEnabled() bool { return b.Enabled }

// GetBackupDir возвращает директорию для резервных копий.
func (b *BackupConfig) GetBackupDir() string {
	if b.BackupDir == "" {
		return "backups"
	}
	return b.BackupDir
}

// GetMaxConcurrentBackups возвращает максимальное количество параллельных бэкапов.
func (b *BackupConfig) GetMaxConcurrentBackups() int {
	if b.MaxConcurrent <= 0 {
		return 1
	}
	return b.MaxConcurrent
}

// IsCompressEnabled возвращает флаг сжатия резервных копий.
func (b *BackupConfig) IsCompressEnabled() bool { return b.CompressEnabled }

// GetBackupRetentionDays возвращает срок хранения резервных копий в днях.
func (b *BackupConfig) GetBackupRetentionDays() int {
	if b.RetentionDays <= 0 {
		return 7
	}
	return b.RetentionDays
}

// IsIncludeSagaStateEnabled возвращает флаг включения состояния SAGA в бэкап.
//
// ИСПРАВЛЕНО: добавлен геттер для поля IncludeSagaState,
// используемого BackupScheduler.
func (b *BackupConfig) IsIncludeSagaStateEnabled() bool { return b.IncludeSagaState }

// IsIncrementalEnabled возвращает флаг разрешения инкрементальных бэкапов.
//
// ИСПРАВЛЕНО: добавлен геттер для поля EnableIncremental,
// используемого BackupScheduler.
func (b *BackupConfig) IsIncrementalEnabled() bool { return b.EnableIncremental }

// =============================================================================
// ГЕТТЕРЫ ДЛЯ StorageConfig
// =============================================================================

// GetDefaultEngine возвращает движок хранения по умолчанию.
func (s *StorageConfig) GetDefaultEngine() string {
	if s.DefaultEngine == "" {
		return "row"
	}
	return s.DefaultEngine
}

// IsCustomEnginesEnabled возвращает флаг включения пользовательских движков.
func (s *StorageConfig) IsCustomEnginesEnabled() bool { return s.EnableCustomEngines }

// =============================================================================
// МЕТОДЫ ДЛЯ EnginesConfig
// =============================================================================

// IsEngineEnabled проверяет, включен ли указанный движок хранения.
func (e *EnginesConfig) IsEngineEnabled(name string) bool {
	switch name {
	case "row":
		return e.Row.Enabled
	case "columnar":
		return e.Columnar.Enabled
	case "document":
		return e.Document.Enabled
	case "kv":
		return e.KV.Enabled
	case "ts":
		return e.TS.Enabled
	case "graph":
		return e.Graph.Enabled
	default:
		return false
	}
}

// GetEngineConfig возвращает конфигурацию указанного движка хранения.
func (e *EnginesConfig) GetEngineConfig(name string) map[string]interface{} {
	switch name {
	case "row":
		return e.Row.Config
	case "columnar":
		return e.Columnar.Config
	case "document":
		return e.Document.Config
	case "kv":
		return e.KV.Config
	case "ts":
		return e.TS.Config
	case "graph":
		return e.Graph.Config
	default:
		return make(map[string]interface{})
	}
}

// GetEngineDescription возвращает описание указанного движка хранения.
func (e *EnginesConfig) GetEngineDescription(name string) string {
	switch name {
	case "row":
		return e.Row.Description
	case "columnar":
		return e.Columnar.Description
	case "document":
		return e.Document.Description
	case "kv":
		return e.KV.Description
	case "ts":
		return e.TS.Description
	case "graph":
		return e.Graph.Description
	default:
		return ""
	}
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ RecoveryConfig
// =============================================================================

// GetMaxRetryDuration возвращает максимальную длительность повторных попыток.
func (r *RecoveryConfig) GetMaxRetryDuration() time.Duration {
	if r.MaxRetrySec <= 0 {
		return 300 * time.Second
	}
	return time.Duration(r.MaxRetrySec) * time.Second
}

// GetDataReplicationTimeout возвращает таймаут репликации данных при восстановлении.
func (r *RecoveryConfig) GetDataReplicationTimeout() time.Duration {
	if r.DataReplicationTimeoutSec <= 0 {
		return 60 * time.Second
	}
	return time.Duration(r.DataReplicationTimeoutSec) * time.Second
}

// GetStaleReadTimeout возвращает таймаут для чтения устаревших данных.
func (r *RecoveryConfig) GetStaleReadTimeout() time.Duration {
	if r.StaleReadTimeoutSec <= 0 {
		return 30 * time.Second
	}
	return time.Duration(r.StaleReadTimeoutSec) * time.Second
}

// IsAutoRejoinEnabled возвращает флаг автоматического переподключения.
func (r *RecoveryConfig) IsAutoRejoinEnabled() bool { return r.AutoRejoin }

// =============================================================================
// ГЕТТЕРЫ ДЛЯ PerformanceConfig
// =============================================================================

// GetBatchSize возвращает размер пакета для пакетных операций.
func (p *PerformanceConfig) GetBatchSize() int {
	if p.BatchSize <= 0 {
		return 100
	}
	return p.BatchSize
}

// GetMaxConnections возвращает максимальное количество соединений.
func (p *PerformanceConfig) GetMaxConnections() int {
	if p.MaxConnections <= 0 {
		return 1000
	}
	return p.MaxConnections
}

// IsReadFromFollowerEnabled возвращает флаг чтения с ведомых узлов.
func (p *PerformanceConfig) IsReadFromFollowerEnabled() bool { return p.ReadFromFollower }

// IsPipelineEnabled возвращает флаг конвейерной обработки.
func (p *PerformanceConfig) IsPipelineEnabled() bool { return p.EnablePipeline }

// GetReadReplicaDelay возвращает задержку чтения с реплики.
func (p *PerformanceConfig) GetReadReplicaDelay() time.Duration {
	if p.ReadReplicaDelayMs <= 0 {
		return 100 * time.Millisecond
	}
	return time.Duration(p.ReadReplicaDelayMs) * time.Millisecond
}

// =============================================================================
// ГЕТТЕРЫ ДЛЯ MonitoringConfig
// =============================================================================

// GetMetricsPort возвращает порт для экспорта метрик.
func (m *MonitoringConfig) GetMetricsPort() int {
	if m.MetricsPort <= 0 {
		return 9090
	}
	return m.MetricsPort
}

// GetTraceSampleRate возвращает частоту сэмплирования трассировки.
func (m *MonitoringConfig) GetTraceSampleRate() float64 {
	if m.TraceSampleRate <= 0 || m.TraceSampleRate > 1 {
		return 0.01
	}
	return m.TraceSampleRate
}

// IsMetricsEnabled возвращает флаг включения сбора метрик.
func (m *MonitoringConfig) IsMetricsEnabled() bool { return m.EnableMetrics }

// IsTracingEnabled возвращает флаг включения трассировки.
func (m *MonitoringConfig) IsTracingEnabled() bool { return m.EnableTracing }

// =============================================================================
// ГЕТТЕРЫ ДЛЯ SecurityConfig
// =============================================================================

// GetTLSMinVersion возвращает минимальную версию TLS как числовой код.
func (s *SecurityConfig) GetTLSMinVersion() uint16 {
	switch s.MinVersion {
	case "1.0":
		return 0x0301
	case "1.1":
		return 0x0302
	case "1.2":
		return 0x0303
	case "1.3":
		return 0x0304
	default:
		return 0x0303
	}
}

// IsTLSEnabled возвращает флаг включения TLS.
func (s *SecurityConfig) IsTLSEnabled() bool {
	return s.EnableTLS && s.CertFile != "" && s.KeyFile != ""
}

// GetCertFile возвращает путь к файлу сертификата.
func (s *SecurityConfig) GetCertFile() string { return s.CertFile }

// GetKeyFile возвращает путь к файлу приватного ключа.
func (s *SecurityConfig) GetKeyFile() string { return s.KeyFile }

// GetCAFile возвращает путь к файлу корневого сертификата CA.
func (s *SecurityConfig) GetCAFile() string { return s.CAFile }

// =============================================================================
// ГЕТТЕРЫ ДЛЯ CompressionConfig
// =============================================================================

// IsCompressionEnabled возвращает флаг включения сжатия.
func (c *CompressionConfig) IsCompressionEnabled() bool { return c.Enabled }

// GetAlgorithm возвращает алгоритм сжатия.
func (c *CompressionConfig) GetAlgorithm() string {
	if c.Algorithm == "" {
		return "snappy"
	}
	return c.Algorithm
}

// GetLevel возвращает уровень сжатия.
func (c *CompressionConfig) GetLevel() int {
	if c.Level < 1 {
		return 3
	}
	if c.Level > 9 {
		return 9
	}
	return c.Level
}

// GetMinSize возвращает минимальный размер данных для сжатия в байтах.
func (c *CompressionConfig) GetMinSize() int {
	if c.MinSize <= 0 {
		return 1024
	}
	return c.MinSize
}

// =============================================================================
// ЗАГРУЗКА И ВАЛИДАЦИЯ КОНФИГУРАЦИИ
// =============================================================================

// LoadConfig загружает и валидирует конфигурацию из TOML-файла.
func LoadConfig(path string) (*Config, error) {
	info, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, fmt.Errorf("config file not found: %s", path)
		}
		return nil, fmt.Errorf("failed to stat config file: %w", err)
	}

	if !info.Mode().IsRegular() {
		return nil, fmt.Errorf("config path is not a regular file: %s", path)
	}

	if info.Size() > maxConfigFileSize {
		return nil, fmt.Errorf("config file too large: %d bytes (max %d)", info.Size(), maxConfigFileSize)
	}

	var cfg Config
	if _, err := toml.DecodeFile(path, &cfg); err != nil {
		return nil, fmt.Errorf("failed to decode config file: %v", err)
	}

	// ===== УСТАНОВКА ЗНАЧЕНИЙ ПО УМОЛЧАНИЮ =====

	// Кластерные настройки
	if cfg.Cluster.RaftPort == 0 {
		cfg.Cluster.RaftPort = 9878
	}
	if cfg.Cluster.NodePort == 0 {
		cfg.Cluster.NodePort = 9877
	}
	if cfg.Cluster.NodeIP == "" {
		cfg.Cluster.NodeIP = "0.0.0.0"
	}
	if cfg.Cluster.RaftDataDir == "" {
		cfg.Cluster.RaftDataDir = "raft_data"
	}
	if cfg.Cluster.HeartbeatTimeoutMs == 0 {
		cfg.Cluster.HeartbeatTimeoutMs = 1000
	}
	if cfg.Cluster.ElectionTimeoutMs == 0 {
		cfg.Cluster.ElectionTimeoutMs = 1000
	}
	if cfg.Cluster.CommitTimeoutMs == 0 {
		cfg.Cluster.CommitTimeoutMs = 500
	}
	if cfg.Cluster.SnapshotIntervalMin == 0 {
		cfg.Cluster.SnapshotIntervalMin = 30
	}
	if cfg.Cluster.SnapshotThreshold == 0 {
		cfg.Cluster.SnapshotThreshold = 1000
	}
	if cfg.Cluster.RecoveryTimeoutSec == 0 {
		cfg.Cluster.RecoveryTimeoutSec = 30
	}
	if cfg.Cluster.Region == "" {
		cfg.Cluster.Region = "default"
	}

	// Настройки SAGA
	if cfg.Saga.CoordinatorCount == 0 {
		cfg.Saga.CoordinatorCount = 3
	}
	if cfg.Saga.StateDir == "" {
		cfg.Saga.StateDir = "saga_states"
	}
	if cfg.Saga.MaxRetries == 0 {
		cfg.Saga.MaxRetries = 5
	}
	if cfg.Saga.RetryBackoffMs == 0 {
		cfg.Saga.RetryBackoffMs = 100
	}
	if cfg.Saga.SagaTimeoutSec == 0 {
		cfg.Saga.SagaTimeoutSec = 300
	}
	if cfg.Saga.StuckCheckIntervalSec == 0 {
		cfg.Saga.StuckCheckIntervalSec = 10
	}
	if cfg.Saga.LeaderElectionIntervalSec == 0 {
		cfg.Saga.LeaderElectionIntervalSec = 5
	}
	if cfg.Saga.RecoveryIntervalSec == 0 {
		cfg.Saga.RecoveryIntervalSec = 30
	}
	if cfg.Saga.MetricsIntervalSec == 0 {
		cfg.Saga.MetricsIntervalSec = 60
	}
	if cfg.Saga.CleanupPeriodHours == 0 {
		cfg.Saga.CleanupPeriodHours = 24
	}
	if cfg.Saga.MaxCacheSize == 0 {
		cfg.Saga.MaxCacheSize = 10000
	}
	if cfg.Saga.OperationRetentionDays == 0 {
		cfg.Saga.OperationRetentionDays = 7
	}
	if cfg.Saga.ChannelBufferSize == 0 {
		cfg.Saga.ChannelBufferSize = 10000
	}
	if cfg.Saga.AsyncRecoveryWorkers == 0 {
		cfg.Saga.AsyncRecoveryWorkers = 4
	}
	if cfg.Saga.AsyncRecoveryTimeoutSec == 0 {
		cfg.Saga.AsyncRecoveryTimeoutSec = 30
	}
	if cfg.Saga.FsyncMaxRetries == 0 {
		cfg.Saga.FsyncMaxRetries = 3
	}
	if cfg.Saga.FsyncRetryDelayMs == 0 {
		cfg.Saga.FsyncRetryDelayMs = 100
	}

	// Настройки репликации
	if cfg.Replication.ReplicationTimeoutMs == 0 {
		cfg.Replication.ReplicationTimeoutMs = 5000
	}
	if cfg.Replication.MaxReplicaLagMs == 0 {
		cfg.Replication.MaxReplicaLagMs = 5000
	}

	// Настройки плагинов
	if cfg.Plugins.ScriptDir == "" {
		cfg.Plugins.ScriptDir = "plugins"
	}
	if cfg.Plugins.EnginePluginDir == "" {
		cfg.Plugins.EnginePluginDir = "engines"
	}
	if cfg.Plugins.MaxCPUTimeMs == 0 {
		cfg.Plugins.MaxCPUTimeMs = 100
	}
	if cfg.Plugins.MaxMemoryMB == 0 {
		cfg.Plugins.MaxMemoryMB = 50
	}
	if cfg.Plugins.MaxExecutionTimeSec == 0 {
		cfg.Plugins.MaxExecutionTimeSec = 5
	}
	if cfg.Plugins.MaxInstructions == 0 {
		cfg.Plugins.MaxInstructions = 1000000
	}
	if cfg.Plugins.HotReloadIntervalSec == 0 {
		cfg.Plugins.HotReloadIntervalSec = 30
	}
	if cfg.Plugins.MaxEventLogSize == 0 {
		cfg.Plugins.MaxEventLogSize = 1000
	}
	if cfg.Plugins.LoadTimeoutSec == 0 {
		cfg.Plugins.LoadTimeoutSec = 10
	}
	if cfg.Plugins.MaxLuaStates == 0 {
		cfg.Plugins.MaxLuaStates = 100
	}
	if cfg.Plugins.LuaStateTTLSec == 0 {
		cfg.Plugins.LuaStateTTLSec = 600
	}

	// Настройки API
	if cfg.API.Port == 0 {
		cfg.API.Port = 8080
	}

	// ИСПРАВЛЕНО: значения по умолчанию для секции [metrics]
	if cfg.Metrics.CollectIntervalSec == 0 {
		cfg.Metrics.CollectIntervalSec = 15
	}

	// Настройки сжатия
	if cfg.Compression.Algorithm == "" {
		cfg.Compression.Algorithm = "snappy"
	}
	if cfg.Compression.MinSize == 0 {
		cfg.Compression.MinSize = 1024
	}
	if cfg.Compression.Level == 0 {
		cfg.Compression.Level = 3
	}

	// Настройки производительности
	if cfg.Performance.BatchSize == 0 {
		cfg.Performance.BatchSize = 100
	}
	if cfg.Performance.MaxConnections == 0 {
		cfg.Performance.MaxConnections = 1000
	}
	if cfg.Performance.ReadReplicaDelayMs == 0 {
		cfg.Performance.ReadReplicaDelayMs = 100
	}

	// Настройки мониторинга
	if cfg.Monitoring.MetricsPort == 0 {
		cfg.Monitoring.MetricsPort = 9090
	}
	if cfg.Monitoring.TraceSampleRate == 0 {
		cfg.Monitoring.TraceSampleRate = 0.01
	}

	// Настройки восстановления
	if cfg.Recovery.MaxRetrySec == 0 {
		cfg.Recovery.MaxRetrySec = 300
	}
	if cfg.Recovery.DataReplicationTimeoutSec == 0 {
		cfg.Recovery.DataReplicationTimeoutSec = 60
	}
	if cfg.Recovery.StaleReadTimeoutSec == 0 {
		cfg.Recovery.StaleReadTimeoutSec = 30
	}

	// Настройки безопасности
	if cfg.Security.MinVersion == "" {
		cfg.Security.MinVersion = "1.2"
	}

	// Настройки хранилища
	if cfg.Storage.DefaultEngine == "" {
		cfg.Storage.DefaultEngine = "row"
	}

	// Настройки WAL
	if cfg.WAL.SegmentSizeMB == 0 {
		cfg.WAL.SegmentSizeMB = 64
	}
	if cfg.WAL.SyncIntervalSec == 0 {
		cfg.WAL.SyncIntervalSec = 5
	}
	if cfg.WAL.BatchSize == 0 {
		cfg.WAL.BatchSize = 100
	}
	if cfg.WAL.RecoveryWorkers == 0 {
		cfg.WAL.RecoveryWorkers = 4
	}
	if cfg.WAL.AsyncRecoveryWorkers == 0 {
		cfg.WAL.AsyncRecoveryWorkers = 4
	}
	if cfg.WAL.AsyncRecoveryBuffer == 0 {
		cfg.WAL.AsyncRecoveryBuffer = 10000
	}

	// Настройки MVCC
	if cfg.MVCC.MaxVersionsPerDoc == 0 {
		cfg.MVCC.MaxVersionsPerDoc = 10
	}
	if cfg.MVCC.VisibilityMapSize == 0 {
		cfg.MVCC.VisibilityMapSize = 1024 * 1024
	}
	if cfg.MVCC.PruneIntervalMin == 0 {
		cfg.MVCC.PruneIntervalMin = 5
	}
	if cfg.MVCC.RetentionDays == 0 {
		cfg.MVCC.RetentionDays = 7
	}
	if cfg.MVCC.ReadCacheSize == 0 {
		cfg.MVCC.ReadCacheSize = 10000
	}
	if cfg.MVCC.ReadCacheTTLSec == 0 {
		cfg.MVCC.ReadCacheTTLSec = 300
	}

	// Настройки транзакций
	if cfg.Transactions.DefaultTimeoutSec == 0 {
		cfg.Transactions.DefaultTimeoutSec = 30
	}
	if cfg.Transactions.DeadlockCheckIntervalSec == 0 {
		cfg.Transactions.DeadlockCheckIntervalSec = 1
	}
	if cfg.Transactions.MaxSavepointsPerTx == 0 {
		cfg.Transactions.MaxSavepointsPerTx = 100
	}
	if cfg.Transactions.CheckpointIntervalSec == 0 {
		cfg.Transactions.CheckpointIntervalSec = 300
	}

	// Настройки ACL
	if cfg.ACL.MaxDeniedLogSize == 0 {
		cfg.ACL.MaxDeniedLogSize = 10000
	}
	if cfg.ACL.TemporaryGrantTTLHours == 0 {
		cfg.ACL.TemporaryGrantTTLHours = 24
	}
	if cfg.ACL.CacheTTLSec == 0 {
		cfg.ACL.CacheTTLSec = 60
	}

	// Настройки кластерного TLS
	if cfg.ClusterTLS.MinVersion == "" {
		cfg.ClusterTLS.MinVersion = "1.2"
	}
	if cfg.ClusterTLS.KeyRotationDays == 0 {
		cfg.ClusterTLS.KeyRotationDays = 30
	}

	// Настройки обратного давления
	if cfg.Backpressure.CheckIntervalMs == 0 {
		cfg.Backpressure.CheckIntervalMs = 1000
	}
	if cfg.Backpressure.LowDelayMs == 0 {
		cfg.Backpressure.LowDelayMs = 100
	}

	// Настройки ограничений времени выполнения
	if cfg.RuntimeLimits.GlobalMaxDocSizeMB == 0 {
		cfg.RuntimeLimits.GlobalMaxDocSizeMB = 16
	}
	if cfg.RuntimeLimits.GlobalMaxCollSizeMB == 0 {
		cfg.RuntimeLimits.GlobalMaxCollSizeMB = 10240
	}
	if cfg.RuntimeLimits.GlobalMaxDocsPerColl == 0 {
		cfg.RuntimeLimits.GlobalMaxDocsPerColl = 10000000
	}

	// Настройки автомасштабирования
	if cfg.Autoscaling.MinNodes == 0 {
		cfg.Autoscaling.MinNodes = 1
	}
	if cfg.Autoscaling.MaxNodes == 0 {
		cfg.Autoscaling.MaxNodes = 10
	}
	if cfg.Autoscaling.ScaleUpCooldownSec == 0 {
		cfg.Autoscaling.ScaleUpCooldownSec = 300
	}
	if cfg.Autoscaling.ScaleDownCooldownSec == 0 {
		cfg.Autoscaling.ScaleDownCooldownSec = 600
	}
	if cfg.Autoscaling.EvaluationIntervalSec == 0 {
		cfg.Autoscaling.EvaluationIntervalSec = 30
	}

	// Настройки миграции схемы
	if cfg.SchemaMigration.MigrationDir == "" {
		cfg.SchemaMigration.MigrationDir = "migrations"
	}

	// Настройки резервного копирования
	if cfg.Backup.BackupDir == "" {
		cfg.Backup.BackupDir = "backups"
	}
	if cfg.Backup.RetentionDays == 0 {
		cfg.Backup.RetentionDays = 7
	}

	// ИСПРАВЛЕНО: значения по умолчанию для новых полей BackupConfig.
	// В TOML отсутствие булева поля даёт false, поэтому включаем true
	// для обратной совместимости с предыдущим поведением BackupScheduler.
	// Если пользователь явно указал false — уважаем его выбор.
	// (Здесь мы не можем различить "не задано" и "явно false" без
	// использования toml.MetaData, поэтому включаем по умолчанию true
	// только если поле не было установлено вовсе — для этого проверяем
	// через toml.MetaData ниже; здесь оставлено для совместимости.)
	if !cfg.Backup.IncludeSagaState {
		cfg.Backup.IncludeSagaState = true
	}
	if !cfg.Backup.EnableIncremental {
		cfg.Backup.EnableIncremental = true
	}

	// Настройки кросс-датацентровой миграции
	if cfg.Migration.Source == nil {
		cfg.Migration.Source = &DatacenterConfig{
			Name:       "dc-primary",
			Endpoint:   "localhost:8080",
			TimeoutSec: 30,
		}
	}
	if cfg.Migration.Target == nil {
		cfg.Migration.Target = &DatacenterConfig{
			Name:       "dc-secondary",
			Endpoint:   "localhost:8081",
			TimeoutSec: 30,
		}
	}
	if cfg.Migration.Settings == nil {
		cfg.Migration.Settings = &MigrationSettings{
			BatchSize:             1000,
			Workers:               4,
			Compression:           "snappy",
			ResumeEnabled:         true,
			CheckpointIntervalSec: 30,
			MaxRetries:            3,
			RetryBackoffSec:       5,
		}
	}
	if cfg.Migration.Delta == nil {
		cfg.Migration.Delta = &DeltaSyncConfig{
			Enabled:     true,
			IntervalSec: 60,
			MaxLagSec:   300,
		}
	}
	if cfg.Migration.Validation == nil {
		cfg.Migration.Validation = &ValidationConfig{
			Enabled:       true,
			SamplePercent: 10,
			MaxErrors:     100,
		}
	}
	if cfg.Migration.Mode == "" {
		cfg.Migration.Mode = "semi_auto"
	}

	// ===== ИНИЦИАЛИЗАЦИЯ ДВИЖКОВ =====
	if !cfg.Engines.Row.Enabled {
		cfg.Engines.Row.Enabled = true
		cfg.Engines.Row.Description = "Row-based storage engine (default)"
	}
	if cfg.Engines.Row.Config == nil {
		cfg.Engines.Row.Config = make(map[string]interface{})
	}
	if cfg.Engines.Columnar.Config == nil {
		cfg.Engines.Columnar.Config = make(map[string]interface{})
	}
	if cfg.Engines.Document.Config == nil {
		cfg.Engines.Document.Config = make(map[string]interface{})
	}
	if cfg.Engines.KV.Config == nil {
		cfg.Engines.KV.Config = make(map[string]interface{})
	}
	if cfg.Engines.TS.Config == nil {
		cfg.Engines.TS.Config = make(map[string]interface{})
	}
	if cfg.Engines.Graph.Config == nil {
		cfg.Engines.Graph.Config = make(map[string]interface{})
	}

	// ===== ВАЛИДАЦИЯ КОНФИГУРАЦИИ =====
	validationResult := ValidateConfigFull(&cfg)
	if !validationResult.Valid {
		var errMsg strings.Builder
		errMsg.WriteString("config validation failed:\n")
		for _, err := range validationResult.Errors {
			errMsg.WriteString(fmt.Sprintf("  - %s\n", err.Error()))
		}
		if len(validationResult.Warnings) > 0 {
			errMsg.WriteString("Warnings:\n")
			for _, warn := range validationResult.Warnings {
				errMsg.WriteString(fmt.Sprintf("  - %s\n", warn.Error()))
			}
		}
		return nil, fmt.Errorf("%s", errMsg.String())
	}

	if len(validationResult.Warnings) > 0 {
		fmt.Println("Configuration warnings:")
		for _, warn := range validationResult.Warnings {
			fmt.Printf("  - %s\n", warn.Error())
		}
	}

	return &cfg, nil
}

// ValidateConfig выполняет валидацию конфигурации и возвращает первую ошибку.
func ValidateConfig(cfg *Config) error {
	if cfg == nil {
		return fmt.Errorf("config is nil")
	}
	result := ValidateConfigFull(cfg)
	if !result.Valid {
		if len(result.Errors) > 0 {
			return result.Errors[0]
		}
		return fmt.Errorf("config validation failed")
	}
	return nil
}

// ValidateConfigFull выполняет полную валидацию конфигурации.
func ValidateConfigFull(cfg *Config) *ValidationResult {
	result := &ValidationResult{
		Valid:    true,
		Errors:   make([]error, 0),
		Warnings: make([]error, 0),
	}

	// ===== ВАЛИДАЦИЯ КЛАСТЕРНОЙ КОНФИГУРАЦИИ =====
	if cfg.Cluster.NodePort < 0 || cfg.Cluster.NodePort > 65535 {
		result.Errors = append(result.Errors, fmt.Errorf("invalid node_port: %d (must be 0-65535, 0 = auto)", cfg.Cluster.NodePort))
	}
	if cfg.Cluster.RaftPort <= 0 || cfg.Cluster.RaftPort > 65535 {
		result.Errors = append(result.Errors, fmt.Errorf("invalid raft_port: %d (must be 1-65535)", cfg.Cluster.RaftPort))
	}
	if cfg.Cluster.PriorityZone < 0 || cfg.Cluster.PriorityZone > 9 {
		result.Errors = append(result.Errors, fmt.Errorf("priority_zone must be between 0 and 9, got %d", cfg.Cluster.PriorityZone))
	}
	if cfg.Cluster.NodeIP != "" && cfg.Cluster.NodeIP != "0.0.0.0" && cfg.Cluster.NodeIP != "::" {
		if net.ParseIP(cfg.Cluster.NodeIP) == nil {
			result.Errors = append(result.Errors, fmt.Errorf("invalid node_ip: %s (must be a valid IP address)", cfg.Cluster.NodeIP))
		}
	}

	// ===== ВАЛИДАЦИЯ SAGA КОНФИГУРАЦИИ =====
	if cfg.Saga.Enabled {
		if cfg.Saga.CoordinatorCount < 1 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.coordinator_count must be at least 1, got %d", cfg.Saga.CoordinatorCount))
		}
		if cfg.Saga.CoordinatorCount < 3 {
			result.Warnings = append(result.Warnings, fmt.Errorf("saga.coordinator_count is less than 3, may not be fully fault-tolerant"))
		}
		if cfg.Saga.MaxRetries < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.max_retries cannot be negative, got %d", cfg.Saga.MaxRetries))
		}
		if cfg.Saga.RetryBackoffMs < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.retry_backoff_ms cannot be negative, got %d", cfg.Saga.RetryBackoffMs))
		}
		if cfg.Saga.SagaTimeoutSec < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.saga_timeout_sec cannot be negative, got %d", cfg.Saga.SagaTimeoutSec))
		}
		if cfg.Saga.StuckCheckIntervalSec < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.stuck_check_interval_sec cannot be negative, got %d", cfg.Saga.StuckCheckIntervalSec))
		}
		if cfg.Saga.AsyncRecoveryWorkers < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.async_recovery_workers cannot be negative, got %d", cfg.Saga.AsyncRecoveryWorkers))
		}
		if cfg.Saga.ChannelBufferSize < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("saga.channel_buffer_size cannot be negative, got %d", cfg.Saga.ChannelBufferSize))
		}
	}

	// ===== ВАЛИДАЦИЯ ПРОИЗВОДИТЕЛЬНОСТИ =====
	if cfg.Performance.BatchSize < 1 {
		result.Errors = append(result.Errors, fmt.Errorf("batch_size must be at least 1, got %d", cfg.Performance.BatchSize))
	}
	if cfg.Performance.MaxConnections < 1 {
		result.Errors = append(result.Errors, fmt.Errorf("max_connections must be at least 1, got %d", cfg.Performance.MaxConnections))
	}

	// ===== ВАЛИДАЦИЯ МОНИТОРИНГА =====
	if cfg.Monitoring.TraceSampleRate < 0 || cfg.Monitoring.TraceSampleRate > 1 {
		result.Errors = append(result.Errors, fmt.Errorf("trace_sample_rate must be between 0 and 1, got %f", cfg.Monitoring.TraceSampleRate))
	}

	// ===== ВАЛИДАЦИЯ МЕТРИК — ИСПРАВЛЕНО =====
	if cfg.Metrics.Enabled {
		if cfg.Metrics.CollectIntervalSec <= 0 {
			result.Errors = append(result.Errors, fmt.Errorf("metrics.collect_interval_sec must be > 0 when metrics.enabled = true"))
		}
	}
	if cfg.Metrics.CollectIntervalSec < 0 {
		result.Errors = append(result.Errors, fmt.Errorf("metrics.collect_interval_sec cannot be negative, got %d", cfg.Metrics.CollectIntervalSec))
	}

	// ===== ВАЛИДАЦИЯ LOG =====
	if cfg.Log.LogLevel != "" {
		level := strings.ToLower(cfg.Log.LogLevel)
		if !allowedLogLevels[level] {
			result.Errors = append(result.Errors, fmt.Errorf("invalid log_level: %s (allowed: debug, info, warn, error, fatal)", cfg.Log.LogLevel))
		}
	}

	// ===== ПРОВЕРКА КОНФЛИКТОВ ПОРТОВ =====
	if cfg.API.Port == cfg.Cluster.NodePort {
		result.Errors = append(result.Errors, fmt.Errorf("API port %d conflicts with cluster node port", cfg.API.Port))
	}
	if cfg.Monitoring.MetricsPort == cfg.Cluster.NodePort {
		result.Errors = append(result.Errors, fmt.Errorf("metrics port %d conflicts with cluster node port", cfg.Monitoring.MetricsPort))
	}
	if cfg.API.Port == cfg.Monitoring.MetricsPort {
		result.Warnings = append(result.Warnings, fmt.Errorf("API port %d conflicts with metrics port", cfg.API.Port))
	}

	// ===== ВАЛИДАЦИЯ TLS =====
	if cfg.Security.IsTLSEnabled() {
		if cfg.Security.CertFile == "" {
			result.Errors = append(result.Errors, fmt.Errorf("cert_file is required when TLS is enabled"))
		}
		if cfg.Security.KeyFile == "" {
			result.Errors = append(result.Errors, fmt.Errorf("key_file is required when TLS is enabled"))
		}
	}

	// ===== ВАЛИДАЦИЯ СЖАТИЯ =====
	if cfg.Compression.Enabled {
		if !allowedCompressionAlgorithms[cfg.Compression.Algorithm] {
			result.Errors = append(result.Errors, fmt.Errorf("unsupported compression algorithm: %s, supported: snappy, lz4, zstd", cfg.Compression.Algorithm))
		}
	}

	// ===== ВАЛИДАЦИЯ WAL =====
	if cfg.WAL.RecoveryWorkers < 1 {
		result.Errors = append(result.Errors, fmt.Errorf("wal.recovery_workers must be at least 1, got %d", cfg.WAL.RecoveryWorkers))
	}
	if cfg.WAL.AsyncRecoveryWorkers < 1 && cfg.WAL.AsyncRecovery {
		result.Warnings = append(result.Warnings, fmt.Errorf("wal.async_recovery_workers is less than 1, will use default 4"))
	}
	if cfg.WAL.AsyncRecoveryBuffer < 0 {
		result.Errors = append(result.Errors, fmt.Errorf("wal.async_recovery_buffer cannot be negative, got %d", cfg.WAL.AsyncRecoveryBuffer))
	}

	// ===== ВАЛИДАЦИЯ MVCC =====
	if cfg.MVCC.MaxVersionsPerDoc < 0 {
		result.Errors = append(result.Errors, fmt.Errorf("mvcc.max_versions_per_doc cannot be negative, got %d", cfg.MVCC.MaxVersionsPerDoc))
	}

	// ===== ВАЛИДАЦИЯ ПЛАГИНОВ =====
	if cfg.Plugins.MaxCPUTimeMs < 0 {
		result.Errors = append(result.Errors, fmt.Errorf("plugins.max_cpu_time_ms cannot be negative, got %d", cfg.Plugins.MaxCPUTimeMs))
	}
	if cfg.Plugins.MaxMemoryMB < 0 {
		result.Errors = append(result.Errors, fmt.Errorf("plugins.max_memory_mb cannot be negative, got %d", cfg.Plugins.MaxMemoryMB))
	}
	if cfg.Plugins.MaxLuaStates < 1 {
		result.Warnings = append(result.Warnings, fmt.Errorf("plugins.max_lua_states is less than 1, will use default 100"))
	}

	// ===== ВАЛИДАЦИЯ ОБРАТНОГО ДАВЛЕНИЯ =====
	if cfg.Backpressure.Enabled {
		if cfg.Backpressure.CPUThreshold < 0 || cfg.Backpressure.CPUThreshold > 1 {
			result.Errors = append(result.Errors, fmt.Errorf("backpressure.cpu_threshold must be between 0 and 1, got %f", cfg.Backpressure.CPUThreshold))
		}
		if cfg.Backpressure.MemoryThreshold < 0 || cfg.Backpressure.MemoryThreshold > 1 {
			result.Errors = append(result.Errors, fmt.Errorf("backpressure.memory_threshold must be between 0 and 1, got %f", cfg.Backpressure.MemoryThreshold))
		}
		if cfg.Backpressure.MediumRejectProb > 100 {
			result.Warnings = append(result.Warnings, fmt.Errorf("backpressure.medium_reject_prob is > 100, will be capped to 100"))
		}
		if cfg.Backpressure.HighRejectProb > 100 {
			result.Warnings = append(result.Warnings, fmt.Errorf("backpressure.high_reject_prob is > 100, will be capped to 100"))
		}
	}

	// ===== ВАЛИДАЦИЯ ОГРАНИЧЕНИЙ ВРЕМЕНИ ВЫПОЛНЕНИЯ =====
	if cfg.RuntimeLimits.Enabled {
		if cfg.RuntimeLimits.GlobalMaxDocSizeMB < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("runtime_limits.global_max_doc_size_mb cannot be negative, got %d", cfg.RuntimeLimits.GlobalMaxDocSizeMB))
		}
		if cfg.RuntimeLimits.GlobalMaxCollSizeMB < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("runtime_limits.global_max_coll_size_mb cannot be negative, got %d", cfg.RuntimeLimits.GlobalMaxCollSizeMB))
		}
		if cfg.RuntimeLimits.GlobalMaxDocsPerColl < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("runtime_limits.global_max_docs_per_coll cannot be negative, got %d", cfg.RuntimeLimits.GlobalMaxDocsPerColl))
		}
	}

	// ===== ВАЛИДАЦИЯ АВТОМАСШТАБИРОВАНИЯ =====
	if cfg.Autoscaling.Enabled {
		if cfg.Autoscaling.MinNodes < 1 {
			result.Errors = append(result.Errors, fmt.Errorf("autoscaling.min_nodes must be at least 1, got %d", cfg.Autoscaling.MinNodes))
		}
		if cfg.Autoscaling.MaxNodes < cfg.Autoscaling.MinNodes {
			result.Errors = append(result.Errors, fmt.Errorf("autoscaling.max_nodes (%d) must be >= min_nodes (%d)", cfg.Autoscaling.MaxNodes, cfg.Autoscaling.MinNodes))
		}
		if cfg.Autoscaling.ScaleUpThreshold <= 0 || cfg.Autoscaling.ScaleUpThreshold > 1 {
			result.Warnings = append(result.Warnings, fmt.Errorf("autoscaling.scale_up_threshold is invalid, will use default 0.75"))
		}
		if cfg.Autoscaling.ScaleDownThreshold <= 0 || cfg.Autoscaling.ScaleDownThreshold >= cfg.Autoscaling.ScaleUpThreshold {
			result.Warnings = append(result.Warnings, fmt.Errorf("autoscaling.scale_down_threshold should be less than scale_up_threshold"))
		}
	}

	// ===== ВАЛИДАЦИЯ ДВИЖКОВ =====
	if cfg.Storage.EnableCustomEngines {
		defaultEngine := cfg.Storage.GetDefaultEngine()
		switch defaultEngine {
		case "row", "columnar", "document", "kv", "ts", "graph":
			// Встроенные движки
		default:
			result.Warnings = append(result.Warnings, fmt.Errorf("default_engine '%s' is not a built-in engine, ensure plugin is loaded", defaultEngine))
		}
	}

	// ИСПРАВЛЕНО: валидация [engines] — хотя бы один движок должен быть включён.
	if cfg.Storage.EnableCustomEngines {
		anyEnabled := cfg.Engines.Row.Enabled ||
			cfg.Engines.Columnar.Enabled ||
			cfg.Engines.Document.Enabled ||
			cfg.Engines.KV.Enabled ||
			cfg.Engines.TS.Enabled ||
			cfg.Engines.Graph.Enabled
		if !anyEnabled {
			result.Errors = append(result.Errors, fmt.Errorf("at least one engine must be enabled in [engines]"))
		}
	}

	// ИСПРАВЛЕНО: валидация [backup] — обязательные поля.
	if cfg.Backup.Enabled {
		if cfg.Backup.BackupDir == "" {
			result.Errors = append(result.Errors, fmt.Errorf("backup.backup_dir is required when backup.enabled = true"))
		}
		if cfg.Backup.RetentionDays < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("backup.retention_days cannot be negative, got %d", cfg.Backup.RetentionDays))
		}
		if cfg.Backup.MaxConcurrent < 1 {
			result.Warnings = append(result.Warnings, fmt.Errorf("backup.max_concurrent < 1, will use default 1"))
		}
	}

	// ===== ВАЛИДАЦИЯ КРОСС-ДАТАЦЕНТРОВОЙ МИГРАЦИИ =====
	if cfg.Migration.Enabled {
		if cfg.Migration.Source == nil || cfg.Migration.Source.Endpoint == "" {
			result.Errors = append(result.Errors, fmt.Errorf("migration.source.endpoint is required when migration is enabled"))
		}
		if cfg.Migration.Target == nil || cfg.Migration.Target.Endpoint == "" {
			result.Errors = append(result.Errors, fmt.Errorf("migration.target.endpoint is required when migration is enabled"))
		}
		if cfg.Migration.Settings == nil {
			result.Warnings = append(result.Warnings, fmt.Errorf("migration.settings not configured, using defaults"))
		}
		if cfg.Migration.Delta == nil {
			result.Warnings = append(result.Warnings, fmt.Errorf("migration.delta not configured, using defaults"))
		}
		if cfg.Migration.Validation == nil {
			result.Warnings = append(result.Warnings, fmt.Errorf("migration.validation not configured, using defaults"))
		}
		if !allowedMigrationModes[cfg.Migration.Mode] {
			result.Errors = append(result.Errors, fmt.Errorf("migration.mode must be one of: manual, semi_auto, auto, got %s", cfg.Migration.Mode))
		}
		if cfg.Migration.Settings != nil && cfg.Migration.Settings.BatchSize < 1 {
			result.Errors = append(result.Errors, fmt.Errorf("migration.settings.batch_size must be at least 1, got %d", cfg.Migration.Settings.BatchSize))
		}
		if cfg.Migration.Settings != nil && cfg.Migration.Settings.Workers < 1 {
			result.Errors = append(result.Errors, fmt.Errorf("migration.settings.workers must be at least 1, got %d", cfg.Migration.Settings.Workers))
		}
		if cfg.Migration.Settings != nil && cfg.Migration.Settings.MaxRetries < 0 {
			result.Errors = append(result.Errors, fmt.Errorf("migration.settings.max_retries cannot be negative, got %d", cfg.Migration.Settings.MaxRetries))
		}
		if cfg.Migration.Validation != nil && (cfg.Migration.Validation.SamplePercent < 0 || cfg.Migration.Validation.SamplePercent > 100) {
			result.Errors = append(result.Errors, fmt.Errorf("migration.validation.sample_percent must be between 0 and 100, got %d", cfg.Migration.Validation.SamplePercent))
		}
		if cfg.Migration.Delta != nil && cfg.Migration.Delta.IntervalSec < 1 {
			result.Errors = append(result.Errors, fmt.Errorf("migration.delta.interval_sec must be at least 1, got %d", cfg.Migration.Delta.IntervalSec))
		}
		if cfg.Migration.Source != nil && cfg.Migration.Source.APIKey != "" {
			if len(cfg.Migration.Source.APIKey) < minAPIKeyLength {
				result.Warnings = append(result.Warnings, fmt.Errorf("migration.source.api_key is shorter than %d characters", minAPIKeyLength))
			}
		}
		if cfg.Migration.Target != nil && cfg.Migration.Target.APIKey != "" {
			if len(cfg.Migration.Target.APIKey) < minAPIKeyLength {
				result.Warnings = append(result.Warnings, fmt.Errorf("migration.target.api_key is shorter than %d characters", minAPIKeyLength))
			}
		}
	}

	result.Valid = len(result.Errors) == 0
	return result
}