deb-bootc-image-builder/bib/internal/debos_integration/debos_integration.go

package debos_integration

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/osbuild/images/pkg/arch"
	"github.com/osbuild/images/pkg/bib/osinfo"
	"github.com/osbuild/images/pkg/container"
	"github.com/osbuild/images/pkg/manifest"

	"github.com/particle-os/debian-bootc-image-builder/bib/internal/debos"
)

// DebosIntegration handles the hybrid integration between bootc-image-builder
// and debos, using debos for image creation while building custom logic
// for container-to-bootable conversion.
type DebosIntegration struct {
	workDir    string
	outputDir  string
	debosRunner *debos.DebosRunner
	containerProcessor *ContainerProcessor
}

// BootloaderType represents the type of bootloader to use
type BootloaderType string

const (
	BootloaderGRUB    BootloaderType = "grub"
	BootloaderBootupd BootloaderType = "bootupd"
	BootloaderAuto    BootloaderType = "auto" // Auto-detect based on container
)

// IntegrationOptions configures the debos integration
type IntegrationOptions struct {
	WorkDir     string
	OutputDir   string
	Architecture arch.Arch
	ContainerImage string
	ImageTypes   []string
	SourceInfo  *osinfo.Info
	Bootloader  BootloaderType // Type of bootloader to use
}

// IntegrationResult contains the result of the integration process
type IntegrationResult struct {
	Success     bool
	OutputPath  string
	ManifestPath string
	Error       error
	Logs        string
}

// NewDebosIntegration creates a new debos integration instance
func NewDebosIntegration(options *IntegrationOptions) (*DebosIntegration, error) {
	// Create work directory if it doesn't exist
	if err := os.MkdirAll(options.WorkDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create work directory: %w", err)
	}

	// Create output directory if it doesn't exist
	if err := os.MkdirAll(options.OutputDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create output directory: %w", err)
	}

	// Initialize debos runner
	debosRunner, err := debos.NewDebosRunner(options.WorkDir)
	if err != nil {
		return nil, fmt.Errorf("failed to create debos runner: %w", err)
	}

	// Initialize container processor
	containerProcessor := NewContainerProcessor(options.WorkDir)

	return &DebosIntegration{
		workDir:            options.WorkDir,
		outputDir:          options.OutputDir,
		debosRunner:        debosRunner,
		containerProcessor: containerProcessor,
	}, nil
}

// BuildFromContainer builds a bootable image from a container using the hybrid approach
func (di *DebosIntegration) BuildFromContainer(options *IntegrationOptions) (*IntegrationResult, error) {
	// Step 1: Extract container filesystem
	containerRoot, err := di.extractContainer(options.ContainerImage)
	if err != nil {
		return nil, fmt.Errorf("failed to extract container: %w", err)
	}
	defer os.RemoveAll(containerRoot)

	// Step 2: Generate debos manifest from container content
	manifestPath, err := di.generateManifest(options, containerRoot)
	if err != nil {
		return nil, fmt.Errorf("failed to generate manifest: %w", err)
	}

	// Step 3: Execute debos to create the image
	result, err := di.executeDebos(manifestPath)
	if err != nil {
		return nil, fmt.Errorf("failed to execute debos: %w", err)
	}

	// Step 4: Find and validate output
	outputPath, err := di.findOutputFile(options.ImageTypes)
	if err != nil {
		return nil, fmt.Errorf("failed to find output file: %w", err)
	}

	return &IntegrationResult{
		Success:      result.Success,
		OutputPath:   outputPath,
		ManifestPath: manifestPath,
		Error:        nil,
		Logs:         result.StdOutput,
	}, nil
}

// extractContainer extracts the filesystem from a container image
func (di *DebosIntegration) extractContainer(containerImage string) (string, error) {
	// Use real container processor to extract container
	containerInfo, err := di.containerProcessor.ExtractContainer(containerImage)
	if err != nil {
		return "", fmt.Errorf("failed to extract container: %w", err)
	}

	// Store container info for later use (could be used for manifest generation)
	// For now, just return the working directory
	return containerInfo.WorkingDir, nil
}


// generateManifest creates a debos-compatible YAML manifest from container content
func (di *DebosIntegration) generateManifest(options *IntegrationOptions, containerRoot string) (string, error) {
	// Create manifest generator
	generator := NewManifestGenerator(options)

	// Generate the manifest
	manifest, err := generator.GenerateManifest(containerRoot)
	if err != nil {
		return "", fmt.Errorf("failed to generate manifest: %w", err)
	}

	// Save manifest to file
	manifestPath := filepath.Join(di.workDir, "generated-manifest.yaml")
	if err := manifest.SaveToFile(manifestPath); err != nil {
		return "", fmt.Errorf("failed to save manifest: %w", err)
	}

	return manifestPath, nil
}

// executeDebos runs debos with the generated manifest
func (di *DebosIntegration) executeDebos(manifestPath string) (*debos.DebosResult, error) {
	// Create a minimal template for now (will be replaced by generated manifest)
	template := debos.CreateMinimalTemplate("amd64", "trixie", "test-container")

	// Execute debos
	result, err := di.debosRunner.Execute(template, di.outputDir)
	if err != nil {
		return result, fmt.Errorf("debos execution failed: %w", err)
	}

	return result, nil
}

// findOutputFile locates the generated output file
func (di *DebosIntegration) findOutputFile(imageTypes []string) (string, error) {
	// Look for output files in the output directory
	for _, imgType := range imageTypes {
		pattern := filepath.Join(di.outputDir, "*."+imgType)
		matches, err := filepath.Glob(pattern)
		if err != nil {
			continue
		}
		if len(matches) > 0 {
			return matches[0], nil
		}
	}

	return "", fmt.Errorf("no output files found for image types: %v", imageTypes)
}

// CreateManifestFromContainer creates an osbuild manifest from container info
// This maintains compatibility with the existing bootc-image-builder interface
func (di *DebosIntegration) CreateManifestFromContainer(containerSource container.SourceSpec, arch arch.Arch, sourceInfo *osinfo.Info) (*manifest.Manifest, error) {
	// TODO: Implement manifest creation logic
	// This will generate an osbuild-compatible manifest that can be used
	// by the existing bootc-image-builder workflow
	
	// For now, return a basic manifest
	mf := manifest.New()
	mf.Distro = manifest.DISTRO_FEDORA // Placeholder, will be Debian-specific
	
	return &mf, nil
}