package managed

import (
	"context"
	"errors"
	"os/exec"
	"strings"
	"testing"
)

func TestNormalizeContainerStatus(t *testing.T) {
	t.Parallel()

	cases := map[string]string{
		"running":    "running",
		"created":    "stopped",
		" exited \n": "stopped",
		"paused":     "stopped",
		"dead":       "failed",
		"removing":   "failed",
		"restarting": "failed",
		"unknown":    "unknown",
		"":           "unknown",
	}

	for input, want := range cases {
		if got := NormalizeContainerStatus(input); got != want {
			t.Fatalf("NormalizeContainerStatus(%q) = %q, want %q", input, got, want)
		}
	}
}

func TestDockerControllerGetContainerStatus(t *testing.T) {
	t.Parallel()

	controller := NewDockerControllerWithRunner(func(ctx context.Context, name string, args ...string) ([]byte, error) {
		if name != "docker" {
			t.Fatalf("name = %q", name)
		}
		return []byte("running\n"), nil
	})

	status, err := controller.GetContainerStatus("store-dwell-alert")
	if err != nil {
		t.Fatalf("GetContainerStatus() error = %v", err)
	}
	if status != "running" {
		t.Fatalf("status = %q", status)
	}
}

func TestDockerControllerRestartContainer(t *testing.T) {
	t.Parallel()

	called := false
	controller := NewDockerControllerWithRunner(func(ctx context.Context, name string, args ...string) ([]byte, error) {
		called = true
		return []byte("store-dwell-alert"), nil
	})

	if err := controller.RestartContainer("store-dwell-alert"); err != nil {
		t.Fatalf("RestartContainer() error = %v", err)
	}
	if !called {
		t.Fatal("runner was not called")
	}
}

func TestDockerControllerRestartContainerIncludesOutputOnError(t *testing.T) {
	t.Parallel()

	controller := NewDockerControllerWithRunner(func(ctx context.Context, name string, args ...string) ([]byte, error) {
		return []byte("permission denied"), errors.New("exit status 1")
	})

	err := controller.RestartContainer("store-dwell-alert")
	if err == nil || !strings.Contains(err.Error(), "permission denied") {
		t.Fatalf("RestartContainer() error = %v, want output included", err)
	}
}

func TestIsDockerUnavailable(t *testing.T) {
	t.Parallel()

	if !IsDockerUnavailable(&exec.Error{Name: "docker", Err: exec.ErrNotFound}) {
		t.Fatal("IsDockerUnavailable() = false, want true")
	}
}