package main

import (
	"context"
	"os"
	"testing"
	"time"

	benadisrac "git.benadis.ru/gitops/benadis-rac"
)

// TestGetDefaultConfig тестирует функцию получения конфигурации по умолчанию
func TestGetDefaultConfig(t *testing.T) {
	cfg := getDefaultConfig()

	if cfg.ConfigPath == "" {
		t.Error("ConfigPath не должен быть пустым")
	}
	if cfg.SecretPath == "" {
		t.Error("SecretPath не должен быть пустым")
	}
	if cfg.ProjectPath == "" {
		t.Error("ProjectPath не должен быть пустым")
	}
	if cfg.LogLevel == "" {
		t.Error("LogLevel не должен быть пустым")
	}

	// Проверяем ожидаемые значения
	expected := ExampleConfig{
		ConfigPath:  "../config.yaml",
		SecretPath:  "../secret.yaml",
		ProjectPath: "../project.yaml",
		LogLevel:    "Info",
	}

	if cfg != expected {
		t.Errorf("Неожиданная конфигурация. Получено: %+v, ожидалось: %+v", cfg, expected)
	}
}

// TestClientCreation тестирует создание клиента с различными конфигурациями
func TestClientCreation(t *testing.T) {
	tests := []struct {
		name        string
		config      benadisrac.Config
		expectError bool
	}{
		{
			name: "Валидная конфигурация",
			config: benadisrac.Config{
				ConfigPath:  "../config.yaml",
				SecretPath:  "../secret.yaml",
				ProjectPath: "../project.yaml",
				LogLevel:    "Info",
			},
			expectError: false,
		},
		{
			name: "Несуществующий файл конфигурации",
			config: benadisrac.Config{
				ConfigPath:  "nonexistent.yaml",
				SecretPath:  "../secret.yaml",
				ProjectPath: "../project.yaml",
				LogLevel:    "Info",
			},
			expectError: true,
		},
		{
			name: "Несуществующий файл секретов",
			config: benadisrac.Config{
				ConfigPath:  "../config.yaml",
				SecretPath:  "nonexistent.yaml",
				ProjectPath: "../project.yaml",
				LogLevel:    "Info",
			},
			expectError: true,
		},
		{
			name: "Несуществующий файл проекта",
			config: benadisrac.Config{
				ConfigPath:  "../config.yaml",
				SecretPath:  "../secret.yaml",
				ProjectPath: "nonexistent.yaml",
				LogLevel:    "Info",
			},
			expectError: true,
		},
		{
			name: "Пустые пути (должны использоваться значения по умолчанию)",
			config: benadisrac.Config{
				LogLevel: "Debug",
			},
			expectError: true, // Файлы по умолчанию не существуют в example директории
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			client, err := benadisrac.NewClient(tt.config)

			if tt.expectError {
				if err == nil {
					t.Error("Ожидалась ошибка, но её не было")
				}
				if client != nil {
					t.Error("Клиент не должен быть создан при ошибке")
				}
			} else {
				if err != nil {
					t.Errorf("Неожиданная ошибка: %v", err)
				}
				if client == nil {
					t.Error("Клиент должен быть создан")
				}
			}
		})
	}
}

// TestClientOperations тестирует операции клиента (требует валидную конфигурацию)
func TestClientOperations(t *testing.T) {
	// Проверяем наличие файлов конфигурации
	cfg := getDefaultConfig()
	if !fileExists(cfg.ConfigPath) || !fileExists(cfg.SecretPath) || !fileExists(cfg.ProjectPath) {
		t.Skip("Пропускаем тест: файлы конфигурации не найдены")
	}

	client, err := benadisrac.NewClient(benadisrac.Config{
		ConfigPath:  cfg.ConfigPath,
		SecretPath:  cfg.SecretPath,
		ProjectPath: cfg.ProjectPath,
		LogLevel:    "Info",
	})
	if err != nil {
		t.Fatalf("Ошибка создания клиента: %v", err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Тестируем получение статуса
	t.Run("GetServiceModeStatus", func(t *testing.T) {
		status, err := client.GetServiceModeStatus(ctx)
		if err != nil {
			t.Errorf("Ошибка получения статуса: %v", err)
		}
		// Статус может быть true или false, оба варианта валидны
		t.Logf("Текущий статус сервисного режима: %t", status)
	})

	// Тестируем включение сервисного режима
	t.Run("EnableServiceMode", func(t *testing.T) {
		err := client.EnableServiceMode(ctx)
		if err != nil {
			t.Errorf("Ошибка включения сервисного режима: %v", err)
		}
	})

	// Тестируем выключение сервисного режима
	t.Run("DisableServiceMode", func(t *testing.T) {
		err := client.DisableServiceMode(ctx)
		if err != nil {
			t.Errorf("Ошибка выключения сервисного режима: %v", err)
		}
	})
}

// TestClientWithContext тестирует работу с контекстом
func TestClientWithContext(t *testing.T) {
	cfg := getDefaultConfig()
	if !fileExists(cfg.ConfigPath) || !fileExists(cfg.SecretPath) || !fileExists(cfg.ProjectPath) {
		t.Skip("Пропускаем тест: файлы конфигурации не найдены")
	}

	client, err := benadisrac.NewClient(benadisrac.Config{
		ConfigPath:  cfg.ConfigPath,
		SecretPath:  cfg.SecretPath,
		ProjectPath: cfg.ProjectPath,
		LogLevel:    "Info",
	})
	if err != nil {
		t.Fatalf("Ошибка создания клиента: %v", err)
	}

	// Тестируем таймаут контекста
	t.Run("ContextTimeout", func(t *testing.T) {
		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)
		defer cancel()

		// Ждем, чтобы контекст истек
		time.Sleep(2 * time.Millisecond)

		_, err := client.GetServiceModeStatus(ctx)
		if err == nil {
			t.Log("Операция завершилась быстрее таймаута или таймаут не обрабатывается")
		} else {
			t.Logf("Ожидаемая ошибка таймаута: %v", err)
		}
	})

	// Тестируем отмену контекста
	t.Run("ContextCancellation", func(t *testing.T) {
		ctx, cancel := context.WithCancel(context.Background())
		cancel() // Отменяем контекст сразу

		_, err := client.GetServiceModeStatus(ctx)
		if err == nil {
			t.Log("Операция завершилась до проверки отмены или отмена не обрабатывается")
		} else {
			t.Logf("Ожидаемая ошибка отмены: %v", err)
		}
	})
}

// TestDemonstrateBasicUsage тестирует функцию демонстрации базового использования
func TestDemonstrateBasicUsage(t *testing.T) {
	cfg := getDefaultConfig()
	if !fileExists(cfg.ConfigPath) || !fileExists(cfg.SecretPath) || !fileExists(cfg.ProjectPath) {
		t.Skip("Пропускаем тест: файлы конфигурации не найдены")
	}

	err := demonstrateBasicUsage()
	if err != nil {
		t.Errorf("Ошибка в демонстрации базового использования: %v", err)
	}
}

// TestDemonstrateErrorHandling тестирует функцию демонстрации обработки ошибок
func TestDemonstrateErrorHandling(t *testing.T) {
	// Эта функция не должна вызывать панику
	defer func() {
		if r := recover(); r != nil {
			t.Errorf("Функция demonstrateErrorHandling вызвала панику: %v", r)
		}
	}()

	demonstrateErrorHandling()
}

// TestMainWithArguments тестирует обработку аргументов командной строки
func TestMainWithArguments(t *testing.T) {
	tests := []struct {
		name string
		args []string
	}{
		{"Help", []string{"program", "--help"}},
		{"Help short", []string{"program", "-h"}},
		{"Errors", []string{"program", "--errors"}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Сохраняем оригинальные аргументы
			origArgs := os.Args
			defer func() { os.Args = origArgs }()

			// Устанавливаем тестовые аргументы
			os.Args = tt.args

			// Проверяем, что функции не вызывают панику
			defer func() {
				if r := recover(); r != nil {
					t.Errorf("Функция вызвала панику с аргументами %v: %v", tt.args, r)
				}
			}()

			// Тестируем отдельные функции вместо main()
			switch tt.name {
			case "Help", "Help short":
				printUsageInstructions()
			case "Errors":
				demonstrateErrorHandling()
			}
		})
	}
}

// Вспомогательные функции

// fileExists проверяет существование файла
func fileExists(filename string) bool {
	_, err := os.Stat(filename)
	return !os.IsNotExist(err)
}

// BenchmarkClientCreation бенчмарк создания клиента
func BenchmarkClientCreation(b *testing.B) {
	cfg := getDefaultConfig()
	if !fileExists(cfg.ConfigPath) || !fileExists(cfg.SecretPath) || !fileExists(cfg.ProjectPath) {
		b.Skip("Пропускаем бенчмарк: файлы конфигурации не найдены")
	}

	config := benadisrac.Config{
		ConfigPath:  cfg.ConfigPath,
		SecretPath:  cfg.SecretPath,
		ProjectPath: cfg.ProjectPath,
		LogLevel:    "Info",
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		client, err := benadisrac.NewClient(config)
		if err != nil {
			b.Fatalf("Ошибка создания клиента: %v", err)
		}
		_ = client
	}
}

// BenchmarkGetStatus бенчмарк получения статуса
func BenchmarkGetStatus(b *testing.B) {
	cfg := getDefaultConfig()
	if !fileExists(cfg.ConfigPath) || !fileExists(cfg.SecretPath) || !fileExists(cfg.ProjectPath) {
		b.Skip("Пропускаем бенчмарк: файлы конфигурации не найдены")
	}

	client, err := benadisrac.NewClient(benadisrac.Config{
		ConfigPath:  cfg.ConfigPath,
		SecretPath:  cfg.SecretPath,
		ProjectPath: cfg.ProjectPath,
		LogLevel:    "Info",
	})
	if err != nil {
		b.Fatalf("Ошибка создания клиента: %v", err)
	}

	ctx := context.Background()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := client.GetServiceModeStatus(ctx)
		if err != nil {
			b.Fatalf("Ошибка получения статуса: %v", err)
		}
	}
}