go-container/templates_test.go

package container

import (
	"testing"

	core "dappco.re/go/core"
	"dappco.re/go/core/io"

	"dappco.re/go/core/container/internal/coreutil"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestTemplates_ListTemplates_Good(t *testing.T) {
	templates := ListTemplates()

	// Should have at least the builtin templates
	assert.GreaterOrEqual(t, len(templates), 2)

	// Find the core-dev template
	var found bool
	for _, tmpl := range templates {
		if tmpl.Name == "core-dev" {
			found = true
			assert.NotEmpty(t, tmpl.Description)
			assert.NotEmpty(t, tmpl.Path)
			break
		}
	}
	assert.True(t, found, "core-dev template should exist")

	// Find the server-php template
	found = false
	for _, tmpl := range templates {
		if tmpl.Name == "server-php" {
			found = true
			assert.NotEmpty(t, tmpl.Description)
			assert.NotEmpty(t, tmpl.Path)
			break
		}
	}
	assert.True(t, found, "server-php template should exist")
}

func TestGetTemplate_CoreDev_Good(t *testing.T) {
	content, err := GetTemplate("core-dev")

	require.NoError(t, err)
	assert.NotEmpty(t, content)
	assert.Contains(t, content, "kernel:")
	assert.Contains(t, content, "linuxkit/kernel")
	assert.Contains(t, content, "${SSH_KEY}")
	assert.Contains(t, content, "services:")
}

func TestGetTemplate_ServerPhp_Good(t *testing.T) {
	content, err := GetTemplate("server-php")

	require.NoError(t, err)
	assert.NotEmpty(t, content)
	assert.Contains(t, content, "kernel:")
	assert.Contains(t, content, "frankenphp")
	assert.Contains(t, content, "${SSH_KEY}")
	assert.Contains(t, content, "${DOMAIN:-localhost}")
}

func TestGetTemplate_NotFound_Bad(t *testing.T) {
	_, err := GetTemplate("nonexistent-template")

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "template not found")
}

func TestApplyVariables_SimpleSubstitution_Good(t *testing.T) {
	content := "Hello ${NAME}, welcome to ${PLACE}!"
	vars := map[string]string{
		"NAME":  "World",
		"PLACE": "Core",
	}

	result, err := ApplyVariables(content, vars)

	require.NoError(t, err)
	assert.Equal(t, "Hello World, welcome to Core!", result)
}

func TestApplyVariables_WithDefaults_Good(t *testing.T) {
	content := "Memory: ${MEMORY:-1024}MB, CPUs: ${CPUS:-2}"
	vars := map[string]string{
		"MEMORY": "2048",
		// CPUS not provided, should use default
	}

	result, err := ApplyVariables(content, vars)

	require.NoError(t, err)
	assert.Equal(t, "Memory: 2048MB, CPUs: 2", result)
}

func TestApplyVariables_AllDefaults_Good(t *testing.T) {
	content := "${HOST:-localhost}:${PORT:-8080}"
	vars := map[string]string{} // No vars provided

	result, err := ApplyVariables(content, vars)

	require.NoError(t, err)
	assert.Equal(t, "localhost:8080", result)
}

func TestApplyVariables_MixedSyntax_Good(t *testing.T) {
	content := `
hostname: ${HOSTNAME:-myhost}
ssh_key: ${SSH_KEY}
memory: ${MEMORY:-512}
`
	vars := map[string]string{
		"SSH_KEY":  "ssh-rsa AAAA...",
		"HOSTNAME": "custom-host",
	}

	result, err := ApplyVariables(content, vars)

	require.NoError(t, err)
	assert.Contains(t, result, "hostname: custom-host")
	assert.Contains(t, result, "ssh_key: ssh-rsa AAAA...")
	assert.Contains(t, result, "memory: 512")
}

func TestApplyVariables_EmptyDefault_Good(t *testing.T) {
	content := "value: ${OPT:-}"
	vars := map[string]string{}

	result, err := ApplyVariables(content, vars)

	require.NoError(t, err)
	assert.Equal(t, "value: ", result)
}

func TestApplyVariables_MissingRequired_Bad(t *testing.T) {
	content := "SSH Key: ${SSH_KEY}"
	vars := map[string]string{} // Missing required SSH_KEY

	_, err := ApplyVariables(content, vars)

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "missing required variables")
	assert.Contains(t, err.Error(), "SSH_KEY")
}

func TestApplyVariables_MultipleMissing_Bad(t *testing.T) {
	content := "${VAR1} and ${VAR2} and ${VAR3}"
	vars := map[string]string{
		"VAR2": "provided",
	}

	_, err := ApplyVariables(content, vars)

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "missing required variables")
	// Should mention both missing vars
	errStr := err.Error()
	assert.True(t, core.Contains(errStr, "VAR1") || core.Contains(errStr, "VAR3"))
}

func TestTemplates_ApplyTemplate_Good(t *testing.T) {
	vars := map[string]string{
		"SSH_KEY": "ssh-rsa AAAA... user@host",
	}

	result, err := ApplyTemplate("core-dev", vars)

	require.NoError(t, err)
	assert.NotEmpty(t, result)
	assert.Contains(t, result, "ssh-rsa AAAA... user@host")
	// Default values should be applied
	assert.Contains(t, result, "core-dev") // HOSTNAME default
}

func TestApplyTemplate_TemplateNotFound_Bad(t *testing.T) {
	vars := map[string]string{
		"SSH_KEY": "test",
	}

	_, err := ApplyTemplate("nonexistent", vars)

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "template not found")
}

func TestApplyTemplate_MissingVariable_Bad(t *testing.T) {
	// server-php requires SSH_KEY
	vars := map[string]string{} // Missing required SSH_KEY

	_, err := ApplyTemplate("server-php", vars)

	assert.Error(t, err)
	assert.Contains(t, err.Error(), "missing required variables")
}

func TestTemplates_ExtractVariables_Good(t *testing.T) {
	content := `
hostname: ${HOSTNAME:-myhost}
ssh_key: ${SSH_KEY}
memory: ${MEMORY:-1024}
cpus: ${CPUS:-2}
api_key: ${API_KEY}
`
	required, optional := ExtractVariables(content)

	// Required variables (no default)
	assert.Contains(t, required, "SSH_KEY")
	assert.Contains(t, required, "API_KEY")
	assert.Len(t, required, 2)

	// Optional variables (with defaults)
	assert.Equal(t, "myhost", optional["HOSTNAME"])
	assert.Equal(t, "1024", optional["MEMORY"])
	assert.Equal(t, "2", optional["CPUS"])
	assert.Len(t, optional, 3)
}

func TestExtractVariables_NoVariables_Good(t *testing.T) {
	content := "This has no variables at all"

	required, optional := ExtractVariables(content)

	assert.Empty(t, required)
	assert.Empty(t, optional)
}

func TestExtractVariables_OnlyDefaults_Good(t *testing.T) {
	content := "${A:-default1} ${B:-default2}"

	required, optional := ExtractVariables(content)

	assert.Empty(t, required)
	assert.Len(t, optional, 2)
	assert.Equal(t, "default1", optional["A"])
	assert.Equal(t, "default2", optional["B"])
}

func TestTemplates_ScanUserTemplates_Good(t *testing.T) {
	// Create a temporary directory with template files
	tmpDir := t.TempDir()

	// Create a valid template file
	templateContent := `# My Custom Template
# A custom template for testing
kernel:
  image: linuxkit/kernel:6.6
`
	err := io.Local.Write(coreutil.JoinPath(tmpDir, "custom.yml"), templateContent)
	require.NoError(t, err)

	// Create a non-template file (should be ignored)
	err = io.Local.Write(coreutil.JoinPath(tmpDir, "readme.txt"), "Not a template")
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	assert.Len(t, templates, 1)
	assert.Equal(t, "custom", templates[0].Name)
	assert.Equal(t, "My Custom Template", templates[0].Description)
}

func TestScanUserTemplates_MultipleTemplates_Good(t *testing.T) {
	tmpDir := t.TempDir()

	// Create multiple template files
	err := io.Local.Write(coreutil.JoinPath(tmpDir, "web.yml"), "# Web Server\nkernel:")
	require.NoError(t, err)
	err = io.Local.Write(coreutil.JoinPath(tmpDir, "db.yaml"), "# Database Server\nkernel:")
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	assert.Len(t, templates, 2)

	// Check names are extracted correctly
	names := make(map[string]bool)
	for _, tmpl := range templates {
		names[tmpl.Name] = true
	}
	assert.True(t, names["web"])
	assert.True(t, names["db"])
}

func TestScanUserTemplates_EmptyDirectory_Good(t *testing.T) {
	tmpDir := t.TempDir()

	templates := scanUserTemplates(tmpDir)

	assert.Empty(t, templates)
}

func TestScanUserTemplates_NonexistentDirectory_Bad(t *testing.T) {
	templates := scanUserTemplates("/nonexistent/path/to/templates")

	assert.Empty(t, templates)
}

func TestTemplates_ExtractTemplateDescription_Good(t *testing.T) {
	tmpDir := t.TempDir()
	path := coreutil.JoinPath(tmpDir, "test.yml")

	content := `# My Template Description
# More details here
kernel:
  image: test
`
	err := io.Local.Write(path, content)
	require.NoError(t, err)

	desc := extractTemplateDescription(path)

	assert.Equal(t, "My Template Description", desc)
}

func TestExtractTemplateDescription_NoComments_Good(t *testing.T) {
	tmpDir := t.TempDir()
	path := coreutil.JoinPath(tmpDir, "test.yml")

	content := `kernel:
  image: test
`
	err := io.Local.Write(path, content)
	require.NoError(t, err)

	desc := extractTemplateDescription(path)

	assert.Empty(t, desc)
}

func TestExtractTemplateDescription_FileNotFound_Bad(t *testing.T) {
	desc := extractTemplateDescription("/nonexistent/file.yml")

	assert.Empty(t, desc)
}

func TestTemplates_VariablePatternEdgeCases_Good(t *testing.T) {
	tests := []struct {
		name     string
		content  string
		vars     map[string]string
		expected string
	}{
		{
			name:     "underscore in name",
			content:  "${MY_VAR:-default}",
			vars:     map[string]string{"MY_VAR": "value"},
			expected: "value",
		},
		{
			name:     "numbers in name",
			content:  "${VAR123:-default}",
			vars:     map[string]string{},
			expected: "default",
		},
		{
			name:     "default with special chars",
			content:  "${URL:-http://localhost:8080}",
			vars:     map[string]string{},
			expected: "http://localhost:8080",
		},
		{
			name:     "default with path",
			content:  "${PATH:-/usr/local/bin}",
			vars:     map[string]string{},
			expected: "/usr/local/bin",
		},
		{
			name:     "adjacent variables",
			content:  "${A:-a}${B:-b}${C:-c}",
			vars:     map[string]string{"B": "X"},
			expected: "aXc",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := ApplyVariables(tt.content, tt.vars)
			require.NoError(t, err)
			assert.Equal(t, tt.expected, result)
		})
	}
}

func TestScanUserTemplates_SkipsBuiltinNames_Good(t *testing.T) {
	tmpDir := t.TempDir()

	// Create a template with a builtin name (should be skipped)
	err := io.Local.Write(coreutil.JoinPath(tmpDir, "core-dev.yml"), "# Duplicate\nkernel:")
	require.NoError(t, err)

	// Create a unique template
	err = io.Local.Write(coreutil.JoinPath(tmpDir, "unique.yml"), "# Unique\nkernel:")
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	// Should only have the unique template, not the builtin name
	assert.Len(t, templates, 1)
	assert.Equal(t, "unique", templates[0].Name)
}

func TestScanUserTemplates_SkipsDirectories_Good(t *testing.T) {
	tmpDir := t.TempDir()

	// Create a subdirectory (should be skipped)
	err := io.Local.EnsureDir(coreutil.JoinPath(tmpDir, "subdir"))
	require.NoError(t, err)

	// Create a valid template
	err = io.Local.Write(coreutil.JoinPath(tmpDir, "valid.yml"), "# Valid\nkernel:")
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	assert.Len(t, templates, 1)
	assert.Equal(t, "valid", templates[0].Name)
}

func TestScanUserTemplates_YamlExtension_Good(t *testing.T) {
	tmpDir := t.TempDir()

	// Create templates with both extensions
	err := io.Local.Write(coreutil.JoinPath(tmpDir, "template1.yml"), "# Template 1\nkernel:")
	require.NoError(t, err)
	err = io.Local.Write(coreutil.JoinPath(tmpDir, "template2.yaml"), "# Template 2\nkernel:")
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	assert.Len(t, templates, 2)

	names := make(map[string]bool)
	for _, tmpl := range templates {
		names[tmpl.Name] = true
	}
	assert.True(t, names["template1"])
	assert.True(t, names["template2"])
}

func TestExtractTemplateDescription_EmptyComment_Good(t *testing.T) {
	tmpDir := t.TempDir()
	path := coreutil.JoinPath(tmpDir, "test.yml")

	// First comment is empty, second has content
	content := `#
# Actual description here
kernel:
  image: test
`
	err := io.Local.Write(path, content)
	require.NoError(t, err)

	desc := extractTemplateDescription(path)

	assert.Equal(t, "Actual description here", desc)
}

func TestExtractTemplateDescription_MultipleEmptyComments_Good(t *testing.T) {
	tmpDir := t.TempDir()
	path := coreutil.JoinPath(tmpDir, "test.yml")

	// Multiple empty comments before actual content
	content := `#
#
#
# Real description
kernel:
  image: test
`
	err := io.Local.Write(path, content)
	require.NoError(t, err)

	desc := extractTemplateDescription(path)

	assert.Equal(t, "Real description", desc)
}

func TestScanUserTemplates_DefaultDescription_Good(t *testing.T) {
	tmpDir := t.TempDir()

	// Create a template without comments
	content := `kernel:
  image: test
`
	err := io.Local.Write(coreutil.JoinPath(tmpDir, "nocomment.yml"), content)
	require.NoError(t, err)

	templates := scanUserTemplates(tmpDir)

	assert.Len(t, templates, 1)
	assert.Equal(t, "User-defined template", templates[0].Description)
}