main_test.go

package main

import (
	"flag"
	"os"
	"path/filepath"
	"strings"
	"syscall"
	"testing"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
	log "github.com/sirupsen/logrus"
)

func TestFlagParsing(t *testing.T) {
	// Save original values
	originalArgs := os.Args
	originalConfigFilePath := *configFilePath
	originalHelp := *help

	defer func() {
		os.Args = originalArgs
		*configFilePath = originalConfigFilePath
		*help = originalHelp
		// Reset flag for next test
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
		configFilePath = flag.String("c", "", "Configuration file location")
		help = flag.Bool("h", false, "Usage information")
	}()

	tests := []struct {
		name       string
		args       []string
		wantHelp   bool
		wantConfig string
	}{
		{
			name:       "help flag",
			args:       []string{"bucketsyncd", "-h"},
			wantHelp:   true,
			wantConfig: "",
		},
		{
			name:       "config flag",
			args:       []string{"bucketsyncd", "-c", "/path/to/config.yaml"},
			wantHelp:   false,
			wantConfig: "/path/to/config.yaml",
		},
		{
			name:       "no flags",
			args:       []string{"bucketsyncd"},
			wantHelp:   false,
			wantConfig: "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Reset flags
			flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
			configFilePath = flag.String("c", "", "Configuration file location")
			help = flag.Bool("h", false, "Usage information")

			os.Args = tt.args
			flag.Parse()

			if *help != tt.wantHelp {
				t.Errorf("help flag: got %v, want %v", *help, tt.wantHelp)
			}
			if *configFilePath != tt.wantConfig {
				t.Errorf("config path: got %v, want %v", *configFilePath, tt.wantConfig)
			}
		})
	}
}

func TestLogLevelConfiguration(t *testing.T) {
	// Save original log level
	originalLevel := log.GetLevel()
	defer log.SetLevel(originalLevel)

	tests := []struct {
		logLevel string
		expected log.Level
	}{
		{"debug", log.DebugLevel},
		{"info", log.InfoLevel},
		{"warn", log.WarnLevel},
		{"error", log.ErrorLevel}, // Default when unspecified
	}

	for _, tt := range tests {
		t.Run(tt.logLevel, func(t *testing.T) {
			// Set config log level
			config.LogLevel = tt.logLevel

			// Apply the log level configuration logic from main()
			switch config.LogLevel {
			case debugLevel:
				log.SetLevel(log.DebugLevel)
			case infoLevel:
				log.SetLevel(log.InfoLevel)
			case warnLevel:
				log.SetLevel(log.WarnLevel)
			default:
				log.SetLevel(log.ErrorLevel)
			}

			if log.GetLevel() != tt.expected {
				t.Errorf("log level: got %v, want %v", log.GetLevel(), tt.expected)
			}
		})
	}
}

func TestLogFormatterConfiguration(t *testing.T) {
	// Save original formatter
	originalFormatter := log.StandardLogger().Formatter
	defer log.SetFormatter(originalFormatter)

	// Test JSON formatter
	config.LogJSON = true
	if config.LogJSON {
		log.SetFormatter(&log.JSONFormatter{})
	}

	// Check that formatter was set (we can't easily test the exact type)
	if log.StandardLogger().Formatter == nil {
		t.Error("Expected JSON formatter to be set")
	}

	// Test text formatter
	config.LogJSON = false
	log.SetFormatter(&log.TextFormatter{
		DisableColors: true,
		FullTimestamp: true,
	})

	if log.StandardLogger().Formatter == nil {
		t.Error("Expected text formatter to be set")
	}
}

func TestConfigurationValidation(t *testing.T) {
	// Test with valid configuration
	tmpDir := t.TempDir()
	configFile := filepath.Join(tmpDir, "valid-config.yaml")
	validContent := `
log_level: "info"
log_json: false
outbound:
  - name: "test-outbound"
    description: "Test configuration"
    source: "/tmp/test/*"
    destination: "s3://test-bucket/uploads/"
    sensitive: false
inbound:
  - name: "test-inbound"
    description: "Test inbound"
    source: "amqp://guest:guest@localhost:5672/"
    exchange: "test-exchange"
    queue: "test-queue"
    remote: "test-remote"
    destination: "/tmp/downloads"
remotes:
  - name: "test-remote"
    endpoint: "localhost:9000"
    accessKey: "test-access"
    secretKey: "test-secret"
`

	err := os.WriteFile(configFile, []byte(validContent), 0600)
	if err != nil {
		t.Fatalf("Failed to create config file: %v", err)
	}

	err = readConfig(configFile)
	if err != nil {
		t.Errorf("Valid configuration should not error: %v", err)
	}

	// Verify configuration was loaded
	if len(config.Outbound) == 0 {
		t.Error("Expected outbound configuration to be loaded")
	}
	if len(config.Inbound) == 0 {
		t.Error("Expected inbound configuration to be loaded")
	}
	if len(config.Remotes) == 0 {
		t.Error("Expected remote configuration to be loaded")
	}
}

func TestOutboundProcessingLoop(t *testing.T) {
	// Test that outbound processing can be initiated
	// This is a smoke test since the actual file watching requires real files

	originalConfig := config
	defer func() { config = originalConfig }()

	config = Config{
		Outbound: []Outbound{
			{
				Name:        "test-outbound",
				Description: "Test outbound for processing",
				Source:      "/tmp/test-nonexistent/*",
				Destination: "s3://test-bucket/uploads/",
				Sensitive:   false,
			},
		},
	}

	// Test that the loop can iterate over outbound configurations
	processedCount := 0
	for i := 0; i < len(config.Outbound); i++ {
		o := config.Outbound[i]
		if o.Name == "test-outbound" {
			processedCount++
		}
	}

	if processedCount != 1 {
		t.Errorf("Expected 1 outbound to be processed, got %d", processedCount)
	}
}

func TestInboundProcessingLoop(t *testing.T) {
	// Test that inbound processing can be initiated
	// This is a smoke test since the actual AMQP connection requires real services

	originalConfig := config
	defer func() { config = originalConfig }()

	config = Config{
		Inbound: []Inbound{
			{
				Name:        "test-inbound",
				Description: "Test inbound for processing",
				Source:      "amqp://guest:guest@localhost:5672/",
				Exchange:    "test-exchange",
				Queue:       "test-queue",
				Remote:      "test-remote",
				Destination: "/tmp/downloads",
			},
		},
	}

	// Test that the loop can iterate over inbound configurations
	processedCount := 0
	for i := 0; i < len(config.Inbound); i++ {
		in := config.Inbound[i]
		if in.Name == "test-inbound" {
			processedCount++
		}
	}

	if processedCount != 1 {
		t.Errorf("Expected 1 inbound to be processed, got %d", processedCount)
	}
}

func TestSignalHandling(t *testing.T) {
	// Test signal channel creation and basic setup
	const signalBufferSize = 2
	c := make(chan os.Signal, signalBufferSize)

	if cap(c) != signalBufferSize {
		t.Errorf("Signal channel capacity: got %d, want %d", cap(c), signalBufferSize)
	}

	// Test that we can send signals to the channel
	c <- syscall.SIGTERM
	select {
	case sig := <-c:
		if sig != syscall.SIGTERM {
			t.Errorf("Received signal: got %v, want %v", sig, syscall.SIGTERM)
		}
	case <-time.After(100 * time.Millisecond):
		t.Error("Signal not received within timeout")
	}
}

func TestInboundCloseFunction(_ *testing.T) {
	// Test inboundClose function with empty connections
	originalConnections := connections
	defer func() { connections = originalConnections }()

	// Test with empty connections slice
	connections = []*amqp.Connection{}
	inboundClose() // Should not panic

	// Test with nil connections slice
	connections = nil
	inboundClose() // Should not panic
}

// createMainTestConfig creates a test configuration file
func createMainTestConfig(t *testing.T) string {
	tmpDir := t.TempDir()
	configFile := filepath.Join(tmpDir, "main-test-config.yaml")

	content := `
log_level: "debug"
log_json: false
outbound:
  - name: "main-test-outbound"
    description: "Main test outbound"
    source: "/tmp/main-test/*"
    destination: "s3://main-test-bucket/uploads/"
    sensitive: false
inbound:
  - name: "main-test-inbound"
    description: "Main test inbound"
    source: "amqp://guest:guest@localhost:5672/"
    exchange: "main-test-exchange"
    queue: "main-test-queue"
    remote: "main-test-remote"
    destination: "/tmp/main-test-downloads"
remotes:
  - name: "main-test-remote"
    endpoint: "localhost:9000"
    accessKey: "main-test-access"
    secretKey: "main-test-secret"
`

	err := os.WriteFile(configFile, []byte(content), 0600)
	if err != nil {
		t.Fatalf("Failed to create main test config: %v", err)
	}

	return configFile
}

// verifyMainConfigurationCounts verifies configuration section counts
func verifyMainConfigurationCounts(t *testing.T) {
	if config.LogLevel != "debug" {
		t.Errorf("Log level: got %s, want debug", config.LogLevel)
	}

	if len(config.Outbound) != 1 {
		t.Errorf("Outbound count: got %d, want 1", len(config.Outbound))
	}

	if len(config.Inbound) != 1 {
		t.Errorf("Inbound count: got %d, want 1", len(config.Inbound))
	}

	if len(config.Remotes) != 1 {
		t.Errorf("Remotes count: got %d, want 1", len(config.Remotes))
	}
}

// verifyMainConfigurationDetails verifies specific configuration details
func verifyMainConfigurationDetails(t *testing.T) {
	// Test that configuration details are correct
	outbound := config.Outbound[0]
	if outbound.Name != "main-test-outbound" {
		t.Errorf("Outbound name: got %s, want main-test-outbound", outbound.Name)
	}

	inbound := config.Inbound[0]
	if inbound.Name != "main-test-inbound" {
		t.Errorf("Inbound name: got %s, want main-test-inbound", inbound.Name)
	}

	remote := config.Remotes[0]
	if remote.Name != "main-test-remote" {
		t.Errorf("Remote name: got %s, want main-test-remote", remote.Name)
	}
}

func TestMainConfigurationFlow(t *testing.T) {
	// Test the main configuration loading flow without running the infinite loop
	configFile := createMainTestConfig(t)

	// Test configuration reading (same as main() would do)
	err := readConfig(configFile)
	if err != nil {
		t.Fatalf("Configuration loading failed: %v", err)
	}

	// Verify the configuration was loaded correctly
	verifyMainConfigurationCounts(t)
	verifyMainConfigurationDetails(t)
}

func TestCommandLineValidation(t *testing.T) {
	tests := []struct {
		name        string
		configPath  string
		helpFlag    bool
		shouldError bool
		description string
	}{
		{
			name:        "missing config path",
			configPath:  "",
			helpFlag:    false,
			shouldError: true,
			description: "should error when config path is empty and help is false",
		},
		{
			name:        "help flag set",
			configPath:  "",
			helpFlag:    true,
			shouldError: false,
			description: "should not error when help flag is set",
		},
		{
			name:        "valid config path",
			configPath:  "/path/to/config.yaml",
			helpFlag:    false,
			shouldError: false,
			description: "should not error when valid config path provided",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Simulate the validation logic from main()
			shouldShowUsage := tt.configPath == "" || tt.helpFlag
			hasError := tt.configPath == "" && !tt.helpFlag

			if hasError != tt.shouldError {
				t.Errorf("%s: expected error=%v, got error=%v",
					tt.description, tt.shouldError, hasError)
			}

			if tt.helpFlag && !shouldShowUsage {
				t.Errorf("Help flag should trigger usage display")
			}
		})
	}
}

func TestRunServiceFunctionExecution(t *testing.T) {
	// Test that runService can be called and terminated gracefully
	originalConfig := config
	originalConnections := connections

	defer func() {
		config = originalConfig
		connections = originalConnections
	}()

	// Set up minimal configuration to trigger the loops
	config = Config{
		Outbound: []Outbound{
			{
				Name:        "test-outbound-run",
				Description: "Test outbound for runService",
				Source:      "/tmp/nonexistent/*",
				Destination: "s3://test-bucket/",
				Sensitive:   false,
			},
		},
		Inbound: []Inbound{
			{
				Name:        "test-inbound-run",
				Description: "Test inbound for runService",
				Source:      "amqp://test@nonexistent-host:5672/",
				Exchange:    "test",
				Queue:       "test",
				Remote:      "test-remote",
				Destination: "/tmp/test",
			},
		},
	}

	// Test the runService function by running it briefly and then terminating
	done := make(chan bool, 1)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				// Functions may panic on connection failures, that's expected
				done <- true
			}
		}()

		// Simulate runService execution by running the setup parts
		// Test the outbound loop
		for i := 0; i < len(config.Outbound); i++ {
			// Don't actually call outbound as it starts goroutines that might not terminate
			_ = config.Outbound[i]
		}

		// Test the inbound loop  
		for i := 0; i < len(config.Inbound); i++ {
			// Don't actually call inbound as it tries to connect to AMQP
			_ = config.Inbound[i]
		}

		// Test signal channel creation
		const signalBufferSize = 2
		c := make(chan os.Signal, signalBufferSize)
		if cap(c) != signalBufferSize {
			t.Errorf("Signal channel capacity should be %d", signalBufferSize)
		}

		// Test done channel
		done <- true
	}()

	select {
	case <-done:
		// Test completed successfully
	case <-time.After(2 * time.Second):
		t.Error("RunService test timed out")
	}
}

func TestUsageMessage(t *testing.T) {
	// Test that usage message contains expected elements
	programName := "bucketsyncd"
	expectedElements := []string{
		"Usage:",
		programName,
		"-c",
		"config_file_path",
		"-h",
	}

	usageMessage := "Usage: " + programName + " [-c <config_file_path>] [-h]"

	for _, element := range expectedElements {
		if !strings.Contains(usageMessage, element) {
			t.Errorf("Usage message missing element: %s", element)
		}
	}
}

func TestParseCommandLineFunction(t *testing.T) {
	// Test actual parseCommandLine function
	
	// Save original values
	originalArgs := os.Args
	originalConfigFilePath := *configFilePath
	originalHelp := *help

	defer func() {
		os.Args = originalArgs
		*configFilePath = originalConfigFilePath
		*help = originalHelp
		// Reset flag for next test
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
		configFilePath = flag.String("c", "", "Configuration file location")
		help = flag.Bool("h", false, "Usage information")
	}()

	t.Run("valid config path", func(t *testing.T) {
		// Reset flags
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
		configFilePath = flag.String("c", "", "Configuration file location")
		help = flag.Bool("h", false, "Usage information")

		os.Args = []string{"bucketsyncd", "-c", "/path/to/config.yaml"}
		
		result := parseCommandLine()
		if !result {
			t.Error("parseCommandLine should return true for valid config path")
		}
		if *configFilePath != "/path/to/config.yaml" {
			t.Errorf("Expected config path '/path/to/config.yaml', got '%s'", *configFilePath)
		}
	})

	t.Run("missing config path", func(t *testing.T) {
		// Reset flags
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
		configFilePath = flag.String("c", "", "Configuration file location")
		help = flag.Bool("h", false, "Usage information")

		os.Args = []string{"bucketsyncd"}
		
		result := parseCommandLine()
		if result {
			t.Error("parseCommandLine should return false for missing config path")
		}
	})

	t.Run("help flag", func(t *testing.T) {
		// Reset flags
		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
		configFilePath = flag.String("c", "", "Configuration file location")
		help = flag.Bool("h", false, "Usage information")

		os.Args = []string{"bucketsyncd", "-h"}
		
		result := parseCommandLine()
		if result {
			t.Error("parseCommandLine should return false when help flag is set")
		}
		if !*help {
			t.Error("Help flag should be true")
		}
	})
}

func TestConfigureLoggingFunction(t *testing.T) {
	// Save original values
	originalLevel := log.GetLevel()
	originalFormatter := log.StandardLogger().Formatter
	originalConfig := config

	defer func() {
		log.SetLevel(originalLevel)
		log.SetFormatter(originalFormatter)
		config = originalConfig
	}()

	tests := []struct {
		name           string
		logLevel       string
		logJSON        bool
		expectedLevel  log.Level
		checkJSON      bool
	}{
		{"debug level", "debug", false, log.DebugLevel, false},
		{"info level", "info", false, log.InfoLevel, false},
		{"warn level", "warn", false, log.WarnLevel, false},
		{"unknown level", "unknown", false, log.WarnLevel, false}, // Should not change from default (which is warn)
		{"json formatter", "info", true, log.InfoLevel, true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Set config
			config.LogLevel = tt.logLevel
			config.LogJSON = tt.logJSON

			// Call the actual function
			configureLogging()

			// Check log level
			if log.GetLevel() != tt.expectedLevel {
				t.Errorf("Expected log level %v, got %v", tt.expectedLevel, log.GetLevel())
			}

			// Check formatter type if testing JSON
			if tt.checkJSON {
				if _, ok := log.StandardLogger().Formatter.(*log.JSONFormatter); !ok {
					t.Error("Expected JSONFormatter to be set")
				}
			}
		})
	}
}

func TestRunServiceSetup(t *testing.T) {
	// Test the setup parts of runService function
	originalConfig := config
	originalConnections := connections

	defer func() {
		config = originalConfig  
		connections = originalConnections
	}()

	// Set up test configuration 
	config = Config{
		Outbound: []Outbound{
			{
				Name:        "test-outbound",
				Description: "Test outbound",
				Source:      "/tmp/nonexistent/*",
				Destination: "s3://test-bucket/",
				Sensitive:   false,
			},
		},
		Inbound: []Inbound{
			{
				Name:        "test-inbound", 
				Description: "Test inbound",
				Source:      "amqp://test@localhost/",
				Exchange:    "test",
				Queue:       "test",
				Remote:      "test",
				Destination: "/tmp/test",
			},
		},
	}

	// Test signal handling setup
	const signalBufferSize = 2
	c := make(chan os.Signal, signalBufferSize)
	
	if cap(c) != signalBufferSize {
		t.Errorf("Signal channel capacity: got %d, want %d", cap(c), signalBufferSize)
	}

	// Test done channel setup
	done := make(chan bool, 1) // Buffered channel
	select {
	case done <- true:
		// Channel is ready
	default:
		t.Error("Done channel should be ready to receive")
	}
	<-done // Clean up the channel

	// Test configuration arrays processing
	outboundCount := len(config.Outbound)
	inboundCount := len(config.Inbound)

	if outboundCount != 1 {
		t.Errorf("Expected 1 outbound config, got %d", outboundCount)
	}
	if inboundCount != 1 {
		t.Errorf("Expected 1 inbound config, got %d", inboundCount)
	}
}