package daemon

import (
	"context"
	"fmt"
	"os"
	"time"

	"banger/internal/api"
	"banger/internal/kernelcat"
)

func (d *Daemon) KernelList(_ context.Context) (api.KernelListResult, error) {
	entries, err := kernelcat.ListLocal(d.layout.KernelsDir)
	if err != nil {
		return api.KernelListResult{}, err
	}
	result := api.KernelListResult{Entries: make([]api.KernelEntry, 0, len(entries))}
	for _, entry := range entries {
		result.Entries = append(result.Entries, kernelEntryToAPI(entry))
	}
	return result, nil
}

func (d *Daemon) KernelShow(_ context.Context, name string) (api.KernelEntry, error) {
	entry, err := kernelcat.ReadLocal(d.layout.KernelsDir, name)
	if err != nil {
		return api.KernelEntry{}, kernelNotFoundIfMissing(name, err)
	}
	return kernelEntryToAPI(entry), nil
}

func (d *Daemon) KernelDelete(_ context.Context, name string) error {
	if err := kernelcat.ValidateName(name); err != nil {
		return err
	}
	return kernelcat.DeleteLocal(d.layout.KernelsDir, name)
}

func kernelEntryToAPI(entry kernelcat.Entry) api.KernelEntry {
	importedAt := ""
	if !entry.ImportedAt.IsZero() {
		importedAt = entry.ImportedAt.UTC().Format(time.RFC3339)
	}
	return api.KernelEntry{
		Name:          entry.Name,
		Distro:        entry.Distro,
		Arch:          entry.Arch,
		KernelVersion: entry.KernelVersion,
		SHA256:        entry.SHA256,
		Source:        entry.Source,
		ImportedAt:    importedAt,
		KernelPath:    entry.KernelPath,
		InitrdPath:    entry.InitrdPath,
		ModulesDir:    entry.ModulesDir,
	}
}

func kernelNotFoundIfMissing(name string, err error) error {
	if err == nil {
		return nil
	}
	if os.IsNotExist(err) {
		return fmt.Errorf("kernel %q not found", name)
	}
	return err
}