package cmd

import (
	"os"
	"os/user"
	"path/filepath"
	"strings"

	"github.com/spf13/cobra"
	"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/config"
	"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/projects"
	"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/remotes"
	"golang.org/x/sys/unix"
)

// This file contains init methods that may be used by
// multiple sub-commands. For instance, the cach and projects
// sub-commands both depend on a cache and may both call the initProjectCache
// func from their PersistentPreRun commands

func initProjectCache(cmd *cobra.Command, args []string) {
	plog.Debug("Running pre-run for cacheCmd")
	conf.Cache.File = conf.ProjectPath + "/.cache.yaml"

	// Backwards-compatible support for singular instance
	opts := make([]*remotes.ClientOpts, 0)

	if conf.GitlabHost != "" {
		opts = append(opts, &remotes.ClientOpts{
			Ctx:   cmd.Context(),
			Host:  conf.GitlabHost,  // deprecated, switch to gitlabs
			Token: conf.GitlabToken, // deprecated, switch to gitlabs
			Name:  conf.GitlabHost,  // not originally supported, use the new gitlabs field
		})
	}

	// If defined, load additional instances
	for _, g := range conf.Gitlabs {
		opts = append(opts, &remotes.ClientOpts{
			Ctx:   cmd.Context(),
			Name:  g.Name,
			Host:  g.Host,
			Token: g.Token,
		})
	}

	// We need at least one GitLab
	if len(opts) < 1 {
		plog.Error("At least one GitLab must be configured. Add to .gitlabs in your config file")
		os.Exit(1)
	}

	// Load all gitlab configs into clients
	var gitlabs *remotes.Clients
	var err error
	gitlabs, err = remotes.NewGitlabClients(opts)
	if err != nil {
		plog.Error("Failed to create GitLab clients", plog.Args("error", err))
		os.Exit(1)
	}

	cacheOpts := &projects.CacheOpts{
		ProjectsPath: conf.ProjectPath,
		Path:         conf.Cache.File,
		TTL:          conf.Cache.Ttl,
		Logger:       plog,
		Gitlabs:      gitlabs,
		Config:       &conf,
	}
	if cache, err = projects.NewProjectCache(cacheOpts); err != nil {
		plog.Error("Failed to prepare project cache", plog.Args("error", err))
		os.Exit(1)
	}

	if err := cache.Read(); err != nil {
		plog.Error("Cache load failed", plog.Args("error", err))
		os.Exit(1)
	}

	plog.Debug("Gitlab Clients", plog.Args("gitlabs", cacheOpts.Gitlabs))
}

func postProjectCache(cmd *cobra.Command, args []string) {
	cache.Write()
}

func initProjectPath(cmd *cobra.Command, args []string) {
	plog.Debug("Running persistent pre-run for rootCmd")
	var err error
	if conf.ProjectPath == "" {
		conf.ProjectPath = config.DefaultConfig.ProjectPath
		return
	}
	if conf.ProjectPath, err = resolvePath(conf.ProjectPath); err != nil {
		plog.Error("Failed to determine project path", plog.Args("error", err))
		os.Exit(1)
	}
	_, err = os.Stat(conf.ProjectPath)
	if err != nil {
		plog.Error("Failed to stat project path, trying to create", plog.Args("error", err))
		if err := os.MkdirAll(conf.ProjectPath, 0750); err != nil {
			plog.Error("Failed to create project path", plog.Args("error", err))
			os.Exit(1)
		}
		plog.Info("Project path created", plog.Args("path", conf.ProjectPath))
	} else {
		if err = unix.Access(conf.ProjectPath, unix.W_OK); err != nil {
			plog.Error("Unable to write to project path", plog.Args(
				"path", conf.ProjectPath,
				"error", err))
			os.Exit(1)
		}
	}
}

func resolvePath(path string) (string, error) {
	if strings.HasPrefix(path, "~/") {
		usr, _ := user.Current()
		path = filepath.Join(usr.HomeDir, path[2:])
	}
	return filepath.Abs(path)
}