package cmd

import (
	"fmt"
	"log"
	"slices"

	"github.com/Jaculabilis/intake/core"
	"github.com/Jaculabilis/intake/web"
	"github.com/spf13/cobra"
)

var listCmd = &cobra.Command{
	Use:     "list",
	GroupID: sourceGroup.ID,
	Aliases: []string{"ls"},
	Short:   "List sources, channels, or actions",
	Long: `List sources, channels, or actions.
`,
	Run: func(cmd *cobra.Command, args []string) {
		list(
			cmd,
			boolArg(cmd, "sources"),
			boolArg(cmd, "channels"),
			boolArg(cmd, "actions"),
			boolArg(cmd, "envs"),
			stringArg(cmd, "argv"),
			stringArg(cmd, "channel"),
			stringArg(cmd, "source"),
		)
	},
}

type OptString struct {
	Value string
}

func init() {
	rootCmd.AddCommand(listCmd)

	listCmd.Flags().Bool("sources", false, "List sources")
	listCmd.Flags().Bool("channels", false, "List channels")
	listCmd.Flags().Bool("actions", false, "List actions for a source")
	listCmd.Flags().Bool("envs", false, "List environment variables for a source")
	listCmd.Flags().String("argv", "", "List command for a source action")
	listCmd.Flags().StringP("channel", "c", "", "List sources in a channel")
	listCmd.MarkFlagsMutuallyExclusive("channels", "sources", "actions", "envs", "channel", "argv")

	listCmd.Flags().StringP("source", "s", "", "")
}

func list(
	cmd *cobra.Command,
	sources bool,
	channels bool,
	actions bool,
	envs bool,
	argv string,
	channel string,
	source string,
) {
	if sources {
		db := openAndMigrateDb()
		names, err := core.GetSources(db)
		if err != nil {
			log.Fatalf("error: failed to get sources: %v", err)
		}
		slices.Sort(names)
		for _, name := range names {
			fmt.Println(name)
		}
	} else if channels {
		db := openAndMigrateDb()
		channelSources, err := core.GetSourcesInChannel(db)
		if err != nil {
			log.Fatalf("error: failed to get sources in channel: %v", err)
		}
		for channel := range channelSources {
			if channel != "" {
				fmt.Println(channel)
			}
		}
	} else if actions {
		if source == "" {
			log.Fatal("error: --source is empty")
		}
		db := openAndMigrateDb()
		actions, err := core.GetActionsForSource(db, source)
		if err != nil {
			log.Fatal(err)
		}
		slices.SortFunc(actions, actionSort)
		for _, action := range actions {
			fmt.Println(action)
		}
	} else if envs {
		if source == "" {
			log.Fatal("error: --source is empty")
		}
		db := openAndMigrateDb()
		envs, err := core.GetEnvs(db, source)
		if err != nil {
			log.Fatalf("error: failed to get envs: %v", err)
		}
		slices.Sort(envs)
		for _, env := range envs {
			fmt.Println(env)
		}
	} else if argv != "" {
		if source == "" {
			log.Fatal("error: --source is empty")
		}
		db := openAndMigrateDb()
		argv, err := core.GetArgvForAction(db, source, argv)
		if err != nil {
			log.Fatalf("error: failed to get argv: %v", err)
		}
		quoted, err := web.Quote(argv)
		if err != nil {
			log.Fatalf("error: %v", err)
		}
		fmt.Println(quoted)
	} else if channel != "" {
		db := openAndMigrateDb()
		channelSources, err := core.GetSourcesInChannel(db)
		if err != nil {
			log.Fatalf("error: failed to get sources in channel: %v", err)
		}
		for _, source := range channelSources[channel] {
			fmt.Println(source)
		}
	} else {
		fmt.Print(cmd.UsageString())
	}
}