package catalogue

import (
	"fmt"
	"os"
	"path"
	"strings"

	"coopcloud.tech/abra/pkg/config"
	gitPkg "coopcloud.tech/abra/pkg/git"
	"github.com/go-git/go-git/v5"
	"github.com/sirupsen/logrus"
)

// CatalogueSkipList is all the repos that are not recipes.
var CatalogueSkipList = map[string]bool{
	"abra":                        true,
	"abra-apps":                   true,
	"abra-aur":                    true,
	"abra-bash":                   true,
	"abra-capsul":                 true,
	"abra-gandi":                  true,
	"abra-hetzner":                true,
	"apps":                        true,
	"aur-abra-git":                true,
	"auto-recipes-catalogue-json": true,
	"auto-mirror":                 true,
	"backup-bot":                  true,
	"backup-bot-two":              true,
	"beta.coopcloud.tech":         true,
	"comrade-renovate-bot":        true,
	"coopcloud.tech":              true,
	"coturn":                      true,
	"docker-cp-deploy":            true,
	"docker-dind-bats-kcov":       true,
	"docs.coopcloud.tech":         true,
	"drone-abra":                  true,
	"example":                     true,
	"gardening":                   true,
	"go-abra":                     true,
	"organising":                  true,
	"pyabra":                      true,
	"radicle-seed-node":           true,
	"recipes-catalogue-json":      true,
	"recipes-wishlist":            true,
	"recipes.coopcloud.tech":      true,
	"stack-ssh-deploy":            true,
	"swarm-cronjob":               true,
	"tagcmp":                      true,
	"traefik-cert-dumper":         true,
	"tyop":                        true,
}

// EnsureCatalogue ensures that the catalogue is cloned locally & present.
func EnsureCatalogue() error {
	catalogueDir := path.Join(config.ABRA_DIR, "catalogue")
	if _, err := os.Stat(catalogueDir); err != nil && os.IsNotExist(err) {
		url := fmt.Sprintf("%s/%s.git", config.REPOS_BASE_URL, config.CATALOGUE_JSON_REPO_NAME)
		if err := gitPkg.Clone(catalogueDir, url); err != nil {
			return err
		}

		logrus.Debugf("cloned catalogue repository to %s", catalogueDir)
	}

	return nil
}

// EnsureUpToDate ensures that the local catalogue has no unstaged changes as
// is up to date. This is useful to run before doing catalogue generation.
func EnsureUpToDate() error {
	isClean, err := gitPkg.IsClean(config.CATALOGUE_DIR)
	if err != nil {
		return err
	}

	if !isClean {
		msg := "%s has locally unstaged changes? please commit/remove your changes before proceeding"
		return fmt.Errorf(msg, config.CATALOGUE_DIR)
	}

	repo, err := git.PlainOpen(config.CATALOGUE_DIR)
	if err != nil {
		return err
	}

	remotes, err := repo.Remotes()
	if err != nil {
		return err
	}

	if len(remotes) == 0 {
		msg := "cannot ensure %s is up-to-date, no git remotes configured"
		logrus.Debugf(msg, config.CATALOGUE_DIR)
		return nil
	}

	worktree, err := repo.Worktree()
	if err != nil {
		return err
	}

	branch, err := gitPkg.CheckoutDefaultBranch(repo, config.CATALOGUE_DIR)
	if err != nil {
		return err
	}

	opts := &git.PullOptions{
		Force:         true,
		ReferenceName: branch,
	}

	if err := worktree.Pull(opts); err != nil {
		if !strings.Contains(err.Error(), "already up-to-date") {
			return err
		}
	}

	logrus.Debugf("fetched latest git changes for %s", config.CATALOGUE_DIR)

	return nil
}