package platform

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

// --- shellEscape tests ---

func TestShellEscapeSimpleStrings(t *testing.T) {
	// Simple alphanumeric strings with safe characters should pass through unchanged
	tests := []string{
		"hello",
		"my-app",
		"web_server",
		"file.txt",
		"/usr/local/bin",
		"key=value",
		"host:port",
		"a,b,c",
		"abc123",
		"A-Z_0.9/path:8080=foo,bar",
	}

	for _, s := range tests {
		got := shellEscape(s)
		if got != s {
			t.Errorf("shellEscape(%q) = %q, want %q (simple string should pass through)", s, got, s)
		}
	}
}

func TestShellEscapeSpecialChars(t *testing.T) {
	// Strings with special characters should be wrapped in single quotes
	tests := []struct {
		input string
		want  string
	}{
		{"hello world", "'hello world'"},
		{"foo;bar", "'foo;bar'"},
		{"$(cmd)", "'$(cmd)'"},
		{"a&b", "'a&b'"},
		{"file name.txt", "'file name.txt'"},
		{"`whoami`", "'`whoami`'"},
		{"a|b", "'a|b'"},
		{"a>b", "'a>b'"},
		{"a<b", "'a<b'"},
		{"hello\nworld", "'hello\nworld'"},
	}

	for _, tt := range tests {
		got := shellEscape(tt.input)
		if got != tt.want {
			t.Errorf("shellEscape(%q) = %q, want %q", tt.input, got, tt.want)
		}
	}
}

func TestShellEscapeSingleQuotes(t *testing.T) {
	// Single quotes within the string must be escaped specially
	input := "it's"
	got := shellEscape(input)
	// The escaping pattern is: wrap in single quotes, replacing ' with '"'"'
	want := "'it'\"'\"'s'"
	if got != want {
		t.Errorf("shellEscape(%q) = %q, want %q", input, got, want)
	}
}

func TestShellEscapeEmptyString(t *testing.T) {
	got := shellEscape("")
	// Empty string is not "safe" (safe && s != ""), so it gets quoted
	if got != "''" {
		t.Errorf("shellEscape(%q) = %q, want %q", "", got, "''")
	}
}

func TestShellEscapeMultipleSingleQuotes(t *testing.T) {
	input := "a'b'c"
	got := shellEscape(input)
	// Each single quote should be escaped
	if !strings.Contains(got, "'") {
		t.Errorf("shellEscape(%q) = %q, expected quoted output", input, got)
	}
	want := "'a'\"'\"'b'\"'\"'c'"
	if got != want {
		t.Errorf("shellEscape(%q) = %q, want %q", input, got, want)
	}
}

// --- sshOptions tests ---

func TestSSHOptionsContainsExpectedOptions(t *testing.T) {
	s := &Server{
		ID:   "srv-1",
		Name: "test-server",
		IP:   "10.0.0.5",
	}

	opts := s.sshOptions()

	expectedPairs := map[string]string{
		"StrictHostKeyChecking": "accept-new",
		"ControlMaster":        "auto",
		"ControlPersist":       "60",
		"ConnectTimeout":       "15",
		"ServerAliveInterval":  "10",
		"ServerAliveCountMax":  "3",
	}

	for key, val := range expectedPairs {
		found := false
		expected := key + "=" + val
		for _, opt := range opts {
			if opt == expected {
				found = true
				break
			}
		}
		if !found {
			t.Errorf("sshOptions() missing %q", expected)
		}
	}
}

func TestSSHOptionsControlPathContainsIP(t *testing.T) {
	s := &Server{IP: "192.168.1.42"}

	opts := s.sshOptions()
	found := false
	for _, opt := range opts {
		if strings.Contains(opt, "ControlPath") && strings.Contains(opt, "192.168.1.42") {
			found = true
			break
		}
	}
	if !found {
		t.Error("sshOptions() ControlPath should contain the server IP")
	}
}

func TestSSHOptionsAllPrefixedWithDashO(t *testing.T) {
	s := &Server{IP: "10.0.0.1"}

	opts := s.sshOptions()
	// Options come in pairs: "-o", "Key=Value"
	if len(opts)%2 != 0 {
		t.Fatalf("sshOptions() returned odd number of elements: %d", len(opts))
	}
	for i := 0; i < len(opts); i += 2 {
		if opts[i] != "-o" {
			t.Errorf("sshOptions()[%d] = %q, want %q", i, opts[i], "-o")
		}
	}
}

// --- sshTimeout tests ---

func TestSSHTimeoutDefault(t *testing.T) {
	s := &Server{}

	got := s.sshTimeout()
	if got != DefaultSSHTimeout {
		t.Errorf("sshTimeout() = %v, want %v (DefaultSSHTimeout)", got, DefaultSSHTimeout)
	}
}

func TestSSHTimeoutCustom(t *testing.T) {
	custom := 5 * time.Minute
	s := &Server{SSHTimeout: custom}

	got := s.sshTimeout()
	if got != custom {
		t.Errorf("sshTimeout() = %v, want %v", got, custom)
	}
}

func TestSSHTimeoutZeroUsesDefault(t *testing.T) {
	s := &Server{SSHTimeout: 0}

	got := s.sshTimeout()
	if got != DefaultSSHTimeout {
		t.Errorf("sshTimeout() with zero = %v, want %v (DefaultSSHTimeout)", got, DefaultSSHTimeout)
	}
}

func TestDefaultSSHTimeoutValue(t *testing.T) {
	if DefaultSSHTimeout != 60*time.Second {
		t.Errorf("DefaultSSHTimeout = %v, want 60s", DefaultSSHTimeout)
	}
}

// --- fileExists tests ---

func TestFileExistsWithExistingFile(t *testing.T) {
	tmp, err := os.CreateTemp("", "congo-test-*")
	if err != nil {
		t.Fatalf("CreateTemp: %v", err)
	}
	defer os.Remove(tmp.Name())
	tmp.Close()

	if !fileExists(tmp.Name()) {
		t.Errorf("fileExists(%q) = false, want true for existing file", tmp.Name())
	}
}

func TestFileExistsWithNonExistentFile(t *testing.T) {
	if fileExists("/tmp/this-file-definitely-does-not-exist-congo-test-12345") {
		t.Error("fileExists returned true for non-existent file")
	}
}

func TestFileExistsWithDirectory(t *testing.T) {
	dir := t.TempDir()
	if !fileExists(dir) {
		t.Errorf("fileExists(%q) = false, want true for existing directory", dir)
	}
}

// --- SSH with hook tests ---

func TestSSHHookInterceptsCall(t *testing.T) {
	var captured []string
	s := &Server{
		IP: "10.0.0.1",
		sshHook: func(args ...string) (string, error) {
			captured = args
			return "mocked output", nil
		},
	}

	output, err := s.SSH("echo", "hello")
	if err != nil {
		t.Fatalf("SSH: unexpected error: %v", err)
	}
	if output != "mocked output" {
		t.Errorf("output = %q, want %q", output, "mocked output")
	}
	if len(captured) != 2 || captured[0] != "echo" || captured[1] != "hello" {
		t.Errorf("captured args = %v, want [echo hello]", captured)
	}
}

func TestSSHHookReturnsError(t *testing.T) {
	s := &Server{
		IP: "10.0.0.1",
		sshHook: func(args ...string) (string, error) {
			return "error output", fmt.Errorf("connection refused")
		},
	}

	output, err := s.SSH("test")
	if err == nil {
		t.Fatal("expected error from SSH hook")
	}
	if output != "error output" {
		t.Errorf("output = %q, want %q", output, "error output")
	}
	if !strings.Contains(err.Error(), "connection refused") {
		t.Errorf("error = %q, want to contain %q", err.Error(), "connection refused")
	}
}

func TestSSHWithTimeoutUsesHook(t *testing.T) {
	called := false
	s := &Server{
		IP: "10.0.0.1",
		sshHook: func(args ...string) (string, error) {
			called = true
			return "", nil
		},
	}

	_, err := s.SSHWithTimeout(5*time.Minute, "docker", "ps")
	if err != nil {
		t.Fatalf("SSHWithTimeout: unexpected error: %v", err)
	}
	if !called {
		t.Error("sshHook was not called by SSHWithTimeout")
	}
}

// --- Copy with hook tests ---

func TestCopyHookInterceptsCall(t *testing.T) {
	var capturedLocal, capturedRemote string
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			capturedLocal = local
			capturedRemote = remote
			return nil
		},
	}

	err := s.Copy("/tmp/local-file", "/remote/path")
	if err != nil {
		t.Fatalf("Copy: unexpected error: %v", err)
	}
	if capturedLocal != "/tmp/local-file" {
		t.Errorf("local = %q, want %q", capturedLocal, "/tmp/local-file")
	}
	if capturedRemote != "/remote/path" {
		t.Errorf("remote = %q, want %q", capturedRemote, "/remote/path")
	}
}

func TestCopyHookReturnsError(t *testing.T) {
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return fmt.Errorf("scp failed")
		},
	}

	err := s.Copy("/tmp/file", "/remote")
	if err == nil {
		t.Fatal("expected error from Copy hook")
	}
	if !strings.Contains(err.Error(), "scp failed") {
		t.Errorf("error = %q, want to contain %q", err.Error(), "scp failed")
	}
}

// --- Write tests ---

func TestWriteCreatesTemp(t *testing.T) {
	var copiedLocal, copiedRemote string
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			copiedLocal = local
			copiedRemote = remote
			// Verify the temp file exists and has the right content
			data, err := os.ReadFile(local)
			if err != nil {
				return fmt.Errorf("read temp file: %w", err)
			}
			if string(data) != "hello world" {
				return fmt.Errorf("temp file content = %q, want %q", string(data), "hello world")
			}
			return nil
		},
		sshHook: func(args ...string) (string, error) {
			return "", nil
		},
	}

	err := s.Write("/remote/file.txt", []byte("hello world"), false)
	if err != nil {
		t.Fatalf("Write: %v", err)
	}
	if copiedLocal == "" {
		t.Error("Copy was not called")
	}
	if copiedRemote != "/remote/file.txt" {
		t.Errorf("remote path = %q, want %q", copiedRemote, "/remote/file.txt")
	}
}

func TestWriteExecutableCallsChmod(t *testing.T) {
	chmodCalled := false
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return nil
		},
		sshHook: func(args ...string) (string, error) {
			if len(args) >= 3 && args[0] == "chmod" && args[1] == "+x" {
				chmodCalled = true
				if args[2] != "/remote/script.sh" {
					return "", fmt.Errorf("chmod path = %q, want %q", args[2], "/remote/script.sh")
				}
			}
			return "", nil
		},
	}

	err := s.Write("/remote/script.sh", []byte("#!/bin/bash"), true)
	if err != nil {
		t.Fatalf("Write: %v", err)
	}
	if !chmodCalled {
		t.Error("chmod was not called for executable file")
	}
}

func TestWriteNonExecutableSkipsChmod(t *testing.T) {
	sshCalled := false
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return nil
		},
		sshHook: func(args ...string) (string, error) {
			sshCalled = true
			return "", nil
		},
	}

	err := s.Write("/remote/config.txt", []byte("data"), false)
	if err != nil {
		t.Fatalf("Write: %v", err)
	}
	if sshCalled {
		t.Error("SSH should not be called for non-executable file")
	}
}

func TestWriteCopyFailure(t *testing.T) {
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return fmt.Errorf("copy failed")
		},
	}

	err := s.Write("/remote/file", []byte("data"), false)
	if err == nil {
		t.Fatal("expected error from Write when Copy fails")
	}
	if !strings.Contains(err.Error(), "copy failed") {
		t.Errorf("error = %q, want to contain %q", err.Error(), "copy failed")
	}
}

func TestWriteCleansTempFile(t *testing.T) {
	var tempPath string
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			tempPath = local
			return nil
		},
	}

	err := s.Write("/remote/file", []byte("data"), false)
	if err != nil {
		t.Fatalf("Write: %v", err)
	}
	if tempPath == "" {
		t.Fatal("Copy was not called")
	}
	// Temp file should be cleaned up after Write returns
	if fileExists(tempPath) {
		t.Errorf("temp file %q was not cleaned up", tempPath)
	}
}

// --- RunScript tests ---

func TestRunScriptNonExistentFile(t *testing.T) {
	s := &Server{IP: "10.0.0.1"}

	err := s.RunScript("/tmp/definitely-nonexistent-script-congo-test.sh")
	if err != nil {
		t.Errorf("RunScript with non-existent file should return nil, got: %v", err)
	}
}

func TestRunScriptExistingFile(t *testing.T) {
	// Create a temp script file
	tmpDir := t.TempDir()
	scriptPath := filepath.Join(tmpDir, "setup.sh")
	if err := os.WriteFile(scriptPath, []byte("echo hello"), 0644); err != nil {
		t.Fatalf("WriteFile: %v", err)
	}

	copyCalled := false
	sshCalls := [][]string{}
	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			copyCalled = true
			if local != scriptPath {
				t.Errorf("Copy local = %q, want %q", local, scriptPath)
			}
			if remote != "/tmp/setup.sh" {
				t.Errorf("Copy remote = %q, want %q", remote, "/tmp/setup.sh")
			}
			return nil
		},
		sshHook: func(args ...string) (string, error) {
			sshCalls = append(sshCalls, args)
			return "script output", nil
		},
	}

	err := s.RunScript(scriptPath)
	if err != nil {
		t.Fatalf("RunScript: %v", err)
	}
	if !copyCalled {
		t.Error("Copy was not called")
	}
	if len(sshCalls) != 1 {
		t.Fatalf("SSH called %d times, want 1", len(sshCalls))
	}
	if sshCalls[0][0] != "bash" || sshCalls[0][1] != "/tmp/setup.sh" {
		t.Errorf("SSH args = %v, want [bash /tmp/setup.sh]", sshCalls[0])
	}
}

func TestRunScriptCopyFailure(t *testing.T) {
	tmpDir := t.TempDir()
	scriptPath := filepath.Join(tmpDir, "setup.sh")
	if err := os.WriteFile(scriptPath, []byte("echo hello"), 0644); err != nil {
		t.Fatalf("WriteFile: %v", err)
	}

	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return fmt.Errorf("upload failed")
		},
	}

	err := s.RunScript(scriptPath)
	if err == nil {
		t.Fatal("expected error when Copy fails")
	}
	if !strings.Contains(err.Error(), "upload") {
		t.Errorf("error = %q, want to contain %q", err.Error(), "upload")
	}
}

func TestRunScriptSSHFailure(t *testing.T) {
	tmpDir := t.TempDir()
	scriptPath := filepath.Join(tmpDir, "setup.sh")
	if err := os.WriteFile(scriptPath, []byte("echo hello"), 0644); err != nil {
		t.Fatalf("WriteFile: %v", err)
	}

	s := &Server{
		IP: "10.0.0.1",
		copyHook: func(local, remote string) error {
			return nil
		},
		sshHook: func(args ...string) (string, error) {
			return "error output", fmt.Errorf("script failed")
		},
	}

	err := s.RunScript(scriptPath)
	if err == nil {
		t.Fatal("expected error when SSH fails")
	}
	if !strings.Contains(err.Error(), "script failed") {
		t.Errorf("error = %q, want to contain %q", err.Error(), "script failed")
	}
}

// --- Server struct tests ---

func TestServerFields(t *testing.T) {
	s := Server{
		ID:        "srv-123",
		Name:      "web-1",
		IP:        "10.0.0.1",
		PrivateIP: "192.168.1.1",
		Size:      "small",
		Region:    "nyc",
		Status:    "active",
	}

	if s.ID != "srv-123" {
		t.Errorf("ID = %q, want %q", s.ID, "srv-123")
	}
	if s.Name != "web-1" {
		t.Errorf("Name = %q, want %q", s.Name, "web-1")
	}
	if s.IP != "10.0.0.1" {
		t.Errorf("IP = %q, want %q", s.IP, "10.0.0.1")
	}
	if s.PrivateIP != "192.168.1.1" {
		t.Errorf("PrivateIP = %q, want %q", s.PrivateIP, "192.168.1.1")
	}
	if s.Size != "small" {
		t.Errorf("Size = %q, want %q", s.Size, "small")
	}
	if s.Region != "nyc" {
		t.Errorf("Region = %q, want %q", s.Region, "nyc")
	}
	if s.Status != "active" {
		t.Errorf("Status = %q, want %q", s.Status, "active")
	}
}

func TestServerSSHTimeoutNegativeUsesDefault(t *testing.T) {
	s := &Server{SSHTimeout: -1 * time.Second}
	got := s.sshTimeout()
	if got != DefaultSSHTimeout {
		t.Errorf("sshTimeout() with negative = %v, want %v", got, DefaultSSHTimeout)
	}
}

// --- WaitForSSH with hook tests ---

func TestWaitForSSHImmediateSuccess(t *testing.T) {
	s := &Server{
		IP: "10.0.0.1",
		sshHook: func(args ...string) (string, error) {
			return "ready", nil
		},
	}

	err := s.WaitForSSH(10 * time.Second)
	if err != nil {
		t.Fatalf("WaitForSSH: unexpected error: %v", err)
	}
}

func TestWaitForSSHTimeout(t *testing.T) {
	s := &Server{
		IP: "10.0.0.1",
		sshHook: func(args ...string) (string, error) {
			return "", fmt.Errorf("connection refused")
		},
	}

	// Use a very short timeout to make the test fast
	err := s.WaitForSSH(1 * time.Millisecond)
	if !errors.Is(err, ErrTimeout) {
		t.Errorf("WaitForSSH error = %v, want ErrTimeout", err)
	}
}

func TestWaitForSSHEventualSuccess(t *testing.T) {
	attempt := 0
	s := &Server{
		IP:         "10.0.0.1",
		SSHTimeout: 100 * time.Millisecond,
		sshHook: func(args ...string) (string, error) {
			attempt++
			if attempt < 3 {
				return "", fmt.Errorf("not ready yet")
			}
			return "ready", nil
		},
	}

	// WaitForSSH sleeps 5s between attempts, so this test uses a short timeout
	// and relies on the hook succeeding eventually. Since the sleep is 5s,
	// we need a timeout long enough. But to keep the test fast, we test
	// immediate success and timeout separately.
	// This test verifies the retry behavior with a very short scenario.
	err := s.WaitForSSH(30 * time.Second)
	if err != nil {
		// Due to the 5-second sleep in WaitForSSH, this may timeout in CI
		// if the total time exceeds the deadline. Skip if it times out.
		if errors.Is(err, ErrTimeout) {
			t.Skip("WaitForSSH timed out due to internal 5s sleep")
		}
		t.Fatalf("WaitForSSH: %v", err)
	}
}