package lockfile

import (
	"fmt"
	"os"

	"git.badhouseplants.net/allanger/shoebill/internal/config/repository"
	"github.com/sirupsen/logrus"
	"gopkg.in/yaml.v2"
)

const LOCKFILE_NAME = "shoebill.lock.yaml"

type LockEntry struct {
	Chart     string
	Release   string
	Version   string
	Namespace string
	RepoUrl   string
	RepoName  string
}

type LockRepository struct {
	URL  string
	Name string
}

type LockFile []*LockEntry

func NewFromFile(dir string) (LockFile, error) {
	var lockEntries LockFile
	lockfilePath := fmt.Sprintf("%s/%s", dir, LOCKFILE_NAME)
	logrus.Infof("reading the lockfile file: %s", lockfilePath)
	lockFile, err := os.ReadFile(lockfilePath)
	if err != nil {
		return nil, err
	}
	if err := yaml.Unmarshal(lockFile, &lockEntries); err != nil {
		return nil, err
	}
	return lockEntries, nil
}

func (lockfile LockFile) ReposFromLockfile() (repository.Repositories, error) {
	reposEntries := []LockRepository{}
	for _, lockentry := range lockfile {
		newRepoEntry := &LockRepository{
			URL:  lockentry.RepoUrl,
			Name: lockentry.RepoName,
		}
		reposEntries = append(reposEntries, *newRepoEntry)
	}
	allKeys := make(map[string]bool)
	dedupedEntries := []LockRepository{}

	for _, repo := range reposEntries {
		if _, value := allKeys[repo.Name]; !value {
			allKeys[repo.Name] = true
			dedupedEntries = append(dedupedEntries, repo)
		}
	}
	repos := repository.Repositories{}

	for _, repoEntry := range dedupedEntries {
		repo := &repository.Repository{
			Name: repoEntry.Name,
			URL:  repoEntry.URL,
		}
		if err := repo.KindFromUrl(); err != nil {
			return nil, err
		}
		repos = append(repos, repo)
	}
	return repos, nil
}

func (lf LockFile) WriteToFile(dir string) error {
	lockfilePath := fmt.Sprintf("%s/%s", dir, LOCKFILE_NAME)
	lockfileContent, err := yaml.Marshal(lf)
	if err != nil {
		return err
	}
	if err := os.WriteFile(lockfilePath, lockfileContent, os.ModeExclusive); err != nil {
		return nil
	}
	return nil
}