package pkg

import (
	"context"
	"fmt"
	"strings"

	pkgcommand "{{.module}}/posh/pkg/command"
	"github.com/foomo/fender/fend"
	"github.com/foomo/posh/pkg/command"
	"github.com/foomo/posh/pkg/config"
	"github.com/foomo/posh/pkg/log"
	"github.com/foomo/posh/integration/ownbrew"
	"github.com/foomo/posh/pkg/plugin"
	"github.com/foomo/posh/pkg/prompt"
	"github.com/foomo/posh/pkg/prompt/check"
	"github.com/foomo/posh/pkg/prompt/history"
	"github.com/foomo/posh/pkg/readline"
	"github.com/foomo/posh/pkg/require"
	"github.com/spf13/viper"
)

type Plugin struct {
	l        log.Logger
	commands command.Commands
}

// ------------------------------------------------------------------------------------------------
// ~ Constructor
// ------------------------------------------------------------------------------------------------

func New(l log.Logger) (plugin.Plugin, error) {
	inst := &Plugin{
		l:        l,
		commands: command.Commands{},
	}

	// add commands
	inst.commands.Add(
		command.NewExit(l),
		command.NewHelp(l, inst.commands),
	)

	// Welcome
	if cmd, err := pkgcommand.NewWelcome(l,
		pkgcommand.WelcomeWithConfigKey("welcome"),
	); err != nil {
		return nil, err
	} else {
		inst.commands.Add(cmd)
	}


	return inst, nil
}

// ------------------------------------------------------------------------------------------------
// ~ Public methods
// ------------------------------------------------------------------------------------------------

func (p *Plugin) Brew(ctx context.Context, cfg config.Ownbrew) error {
	brew, err := ownbrew.New(p.l,
		ownbrew.WithDry(cfg.Dry),
		ownbrew.WithBinDir(cfg.BinDir),
		ownbrew.WithTapDir(cfg.TapDir),
		ownbrew.WithTempDir(cfg.TempDir),
		ownbrew.WithCellarDir(cfg.CellarDir),
		ownbrew.WithPackages(cfg.Packages...),
	)
	if err != nil {
		return err
	}
	return brew.Install(ctx)
}

func (p *Plugin) Require(ctx context.Context, cfg config.Require) error {
	return require.First(p.l,
		require.Envs(p.l, cfg.Envs),
		require.Packages(ctx, p.l, cfg.Packages),
		require.Scripts(ctx, p.l, cfg.Scripts),
	)
}

func (p *Plugin) Execute(ctx context.Context, args []string) error {
	r, err := readline.New(p.l)
	if err != nil {
		return err
	}

	if err := r.Parse(strings.Join(args, " ")); err != nil {
		return err
	}

	if cmd := p.commands.Get(r.Cmd()); cmd == nil {
		return fmt.Errorf("invalid [cmd] argument: %s", r.Cmd())
	} else {
		if value, ok := cmd.(command.Validator); ok {
			if err := value.Validate(ctx, r); err != nil {
				return err
			}
		}
		if err := cmd.Execute(ctx, r); err != nil {
			return err
		}
	}

	return nil
}

func (p *Plugin) Prompt(ctx context.Context, cfg config.Prompt) error {
	sh, err := prompt.New(p.l,
		prompt.WithTitle(cfg.Title),
		prompt.WithPrefix(cfg.Prefix),
		prompt.WithContext(ctx),
		prompt.WithCommands(p.commands),
		prompt.WithCheckers(
			func(ctx context.Context, l log.Logger) check.Info {
				return check.Info{
					Name:   "example",
					Note:   "all good",
					Status: check.StatusSuccess,
				}
			},
		),
		prompt.WithFileHistory(
			history.FileWithLimit(cfg.History.Limit),
			history.FileWithFilename(cfg.History.Filename),
			history.FileWithLockFilename(cfg.History.LockFilename),
		),
	)
	if err != nil {
		return err
	}
	return sh.Run()
}