package config

import (
	"fmt"
	"os"

	"gitea.elkins.co/Networking/ccl/internal/pkg/container"
	"gitea.elkins.co/Networking/ccl/internal/pkg/network"
	"github.com/emirpasic/gods/sets/hashset"
	toml "github.com/pelletier/go-toml"
	"golang.org/x/exp/slices"
)

const (
	CONFIG_FILE_DEFAULT = "/etc/ccl.toml"
)

type command string

var (
	ConfigFile string = CONFIG_FILE_DEFAULT
	networks          = &[]network.Network{}
	containers        = &[]container.Container{}
	categories        = &[]string{}
)

func Categories() []string {
	if categories != nil {
		return *categories
	}
	categories = &[]string{"all"}
	gs := hashset.New()
	for _, c := range *containers {
		gs.Add(c.Category)
	}
	for _, c := range gs.Values() {
		*categories = append(*categories, c.(string))
	}
	return *categories
}

func Union(ids []string) (conts []container.Container) {
	if len(ids) == 0 {
		return *containers
	}
	h := hashset.New()
	for _, id := range ids {
		for _, c := range *containers {
			if id == "all" || c.Name == id || c.Category == id {
				h.Add(c.Name)
			}
		}
	}
	for _, c := range h.Values() {
		name := c.(string)
		match := slices.IndexFunc(*containers, func(c container.Container) bool { return c.Name == name })
		conts = append(conts, (*containers)[match])
	}
	return
}

// A parsing convenience
type parse struct {
	Networks   []network.Network
	Containers []container.Container
}

func Init() error {
	f, err := os.ReadFile(ConfigFile)
	if err != nil {
		return err
	}
	p := parse{}
	err = toml.Unmarshal(f, &p)
	if err != nil {
		return err
	}
	containers, networks = &p.Containers, &p.Networks
	for i := range p.Containers {
		p.Containers[i].Init(networks)
	}
	return nil
}

func NetworkDefaults(name string) (net *network.Network) {
	for _, n := range *networks {
		if n.Name == name {
			net = &n
		}
	}
	return
}

func PrintCreate(ct *container.Container) {
	for _, c := range ct.CreateCommands() {
		fmt.Println(c)
	}
}

func PrintStart(ct *container.Container) {
	for _, c := range ct.StartCommands() {
		fmt.Println(c)
	}
}