package cmd

import (
	"context"
	"flag"
	"fmt"

	"code.icb4dc0.de/buildr/buildr/internal/slices"
	"code.icb4dc0.de/buildr/buildr/modules"

	"code.icb4dc0.de/buildr/buildr/internal/config"

	"github.com/spf13/cobra"
)

var _ flag.Value = (*PagerColor)(nil)

type PagerColor string

func (p *PagerColor) String() string {
	s := string(*p)
	if s == "" {
		return string(PagerColorAuto)
	}

	return s
}

func (p *PagerColor) Set(s string) error {
	switch s {
	case "":
		fallthrough
	case "auto":
		*p = PagerColorAuto
	case "always":
		*p = PagerColorAlways
	case "never":
		*p = PagerColorNever
	default:
		return fmt.Errorf("value %q is not a valid PagerColor", s)
	}
	return nil
}

const (
	PagerColorAuto   PagerColor = "auto"
	PagerColorAlways PagerColor = "always"
	PagerColorNever  PagerColor = "never"
)

type ManConfig struct {
	ColorOutput  PagerColor
	PagerCommand string
}

func (m *ManConfig) Flags() *flag.FlagSet {
	fs := flag.NewFlagSet("man", flag.ExitOnError)

	fs.StringVar(&m.PagerCommand, "pager.command", config.StringEnvOr("BUILDR_PAGER", ""), "pager command - e.g. bat -l md")
	fs.Var(&m.ColorOutput, "pager.color", "Whether to use colorized output or not - auto means it won't colorize when using an external pager")

	return fs
}

func (m *ManConfig) Pager(ctx context.Context, title string) (Pager, error) {
	switch m.PagerCommand {
	case "":
		return NewTUIPager(title)
	default:
		return NewCmdPager(ctx, m.PagerCommand, m.ColorOutput == PagerColorAlways)
	}
}

func ModuleManCommand(
	category modules.Category,
	cmder ManCommander,
	initializer LevelInitializer,
	argsProvider KnownModulesArgProvider,
	manCfg *ManConfig,
) *cobra.Command {
	return &cobra.Command{
		Use:               modules.CategoryName(category),
		Short:             fmt.Sprintf("Show manual pages for %s modules", modules.CategoryName(category)),
		SilenceUsage:      true,
		SilenceErrors:     true,
		Args:              cobra.ExactArgs(1),
		ValidArgsFunction: argsProvider.ValidModulesArgs,
		RunE: func(cmd *cobra.Command, args []string) (err error) {
			if err := initializer.InitAt(cmd.Context(), InitLevelBuildRConfig); err != nil {
				return err
			}

			p, err := manCfg.Pager(cmd.Context(), fmt.Sprintf("Manual - %s/%s", modules.CategoryName(category), args[0]))
			if err != nil {
				return err
			}

			return cmder.DisplayModuleManual(cmd.Context(), p, category, args[0])
		},
	}
}

func ManCmd(
	cmder ManCommander,
	initializer LevelInitializer,
	registryAcc TypeRegistryAccessor,
) *cobra.Command {
	var manCfg ManConfig
	manCmd := &cobra.Command{
		Use:           "man",
		Short:         "Show manual pages",
		SilenceUsage:  true,
		SilenceErrors: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			if err := initializer.InitAt(cmd.Context(), InitLevelBuildRConfig); err != nil {
				return err
			}

			p, err := manCfg.Pager(cmd.Context(), "Manual - modules")
			if err != nil {
				return err
			}
			return cmder.DisplayModulesManual(p)
		},
	}

	manCmd.AddCommand(slices.Map(modules.Categories(), func(c modules.Category) *cobra.Command {
		return ModuleManCommand(
			c,
			cmder,
			initializer,
			ModulesArgsProviderFor(initializer, registryAcc, c),
			&manCfg,
		)
	})...)

	manCmd.PersistentFlags().AddGoFlagSet(manCfg.Flags())

	return manCmd
}