package debos

import (
	"os"
	"strings"
	"testing"

	"github.com/osbuild/images/pkg/arch"
)

func TestNewDebosBuilder(t *testing.T) {
	// Create temporary directories
	workDir, err := os.MkdirTemp("", "debos-builder-work")
	if err != nil {
		t.Fatalf("Failed to create temp work directory: %v", err)
	}
	defer os.RemoveAll(workDir)

	outputDir, err := os.MkdirTemp("", "debos-builder-output")
	if err != nil {
		t.Fatalf("Failed to create temp output directory: %v", err)
	}
	defer os.RemoveAll(outputDir)

	// Test creating builder
	builder, err := NewDebosBuilder(workDir, outputDir)
	if err != nil {
		t.Fatalf("Failed to create debos builder: %v", err)
	}

	if builder == nil {
		t.Fatal("Builder should not be nil")
	}

	if builder.workDir != workDir {
		t.Errorf("Expected workDir %s, got %s", workDir, builder.workDir)
	}

	if builder.outputDir != outputDir {
		t.Errorf("Expected outputDir %s, got %s", outputDir, builder.outputDir)
	}
}

func TestBuildOptions(t *testing.T) {
	arch, err := arch.FromString("amd64")
	if err != nil {
		t.Fatalf("Failed to create arch: %v", err)
	}

	options := &BuildOptions{
		Architecture:   arch,
		Suite:          "trixie",
		ContainerImage: "debian:trixie",
		ImageTypes:     []string{"qcow2"},
		OutputDir:      "/tmp",
		WorkDir:        "/tmp",
		CustomPackages: []string{"vim", "htop"},
	}

	if options.Architecture.String() != "x86_64" {
		t.Errorf("Expected architecture x86_64, got %s", options.Architecture.String())
	}

	if options.Suite != "trixie" {
		t.Errorf("Expected suite trixie, got %s", options.Suite)
	}

	if len(options.ImageTypes) != 1 || options.ImageTypes[0] != "qcow2" {
		t.Errorf("Expected image types [qcow2], got %v", options.ImageTypes)
	}

	if len(options.CustomPackages) != 2 {
		t.Errorf("Expected 2 custom packages, got %d", len(options.CustomPackages))
	}
}

func TestDetectSuiteFromImage(t *testing.T) {
	// Create temporary directories
	workDir, err := os.MkdirTemp("", "debos-builder-work")
	if err != nil {
		t.Fatalf("Failed to create temp work directory: %v", err)
	}
	defer os.RemoveAll(workDir)

	outputDir, err := os.MkdirTemp("", "debos-builder-output")
	if err != nil {
		t.Fatalf("Failed to create temp output directory: %v", err)
	}
	defer os.RemoveAll(outputDir)

	builder, err := NewDebosBuilder(workDir, outputDir)
	if err != nil {
		t.Fatalf("Failed to create debos builder: %v", err)
	}

	// Test suite detection
	testCases := []struct {
		imageName string
		expected  string
	}{
		{"debian:bookworm", "bookworm"},
		{"debian:trixie", "trixie"},
		{"debian:sid", "sid"},
		{"debian:latest", "trixie"}, // default
	}

	for _, tc := range testCases {
		suite := builder.detectSuiteFromImage(tc.imageName)
		if suite != tc.expected {
			t.Errorf("For image %s, expected suite %s, got %s", tc.imageName, tc.expected, suite)
		}
	}
}

func TestContains(t *testing.T) {
	slice := []string{"qcow2", "raw", "ami"}
	
	if !contains(slice, "qcow2") {
		t.Error("Expected contains to find qcow2")
	}
	
	if !contains(slice, "raw") {
		t.Error("Expected contains to find raw")
	}
	
	if contains(slice, "iso") {
		t.Error("Expected contains to not find iso")
	}
}

func TestGeneratePackageInstallScript(t *testing.T) {
	// Create temporary directories
	workDir, err := os.MkdirTemp("", "debos-builder-work")
	if err != nil {
		t.Fatalf("Failed to create temp work directory: %v", err)
	}
	defer os.RemoveAll(workDir)

	outputDir, err := os.MkdirTemp("", "debos-builder-output")
	if err != nil {
		t.Fatalf("Failed to create temp output directory: %v", err)
	}
	defer os.RemoveAll(outputDir)

	builder, err := NewDebosBuilder(workDir, outputDir)
	if err != nil {
		t.Fatalf("Failed to create debos builder: %v", err)
	}

	packages := []string{"vim", "htop", "curl"}
	script := builder.generatePackageInstallScript(packages)
	
	expectedPackages := "vim htop curl"
	if !strings.Contains(script, expectedPackages) {
		t.Errorf("Expected script to contain packages %s, got script: %s", expectedPackages, script)
	}
}