package kingpin

import (
	"fmt"
)

type argGroup struct {
	args []*ArgClause
}

func newArgGroup() *argGroup {
	return &argGroup{}
}

func (a *argGroup) have() bool {
	return len(a.args) > 0
}

// GetArg gets an argument definition.
//
// This allows existing arguments to be modified after definition but before parsing. Useful for
// modular applications.
func (a *argGroup) GetArg(name string) *ArgClause {
	for _, arg := range a.args {
		if arg.name == name {
			return arg
		}
	}
	return nil
}

func (a *argGroup) Arg(name, help string) *ArgClause {
	arg := newArg(name, help)
	a.args = append(a.args, arg)
	return arg
}

func (a *argGroup) init() error {
	required := 0
	seen := map[string]struct{}{}
	previousArgMustBeLast := false
	for i, arg := range a.args {
		if previousArgMustBeLast {
			return fmt.Errorf("Args() can't be followed by another argument '%s'", arg.name)
		}
		if arg.consumesRemainder() {
			previousArgMustBeLast = true
		}
		if _, ok := seen[arg.name]; ok {
			return fmt.Errorf("duplicate argument '%s'", arg.name)
		}
		seen[arg.name] = struct{}{}
		if arg.required && required != i {
			return fmt.Errorf("required arguments found after non-required")
		}
		if arg.required {
			required++
		}
		if err := arg.init(); err != nil {
			return err
		}
	}
	return nil
}

type ArgClause struct {
	actionMixin
	parserMixin
	completionsMixin
	envarMixin
	name          string
	help          string
	defaultValues []string
	required      bool
}

func newArg(name, help string) *ArgClause {
	a := &ArgClause{
		name: name,
		help: help,
	}
	return a
}

func (a *ArgClause) setDefault() error {
	if a.HasEnvarValue() {
		if v, ok := a.value.(remainderArg); !ok || !v.IsCumulative() {
			// Use the value as-is
			return a.value.Set(a.GetEnvarValue())
		}
		for _, value := range a.GetSplitEnvarValue() {
			if err := a.value.Set(value); err != nil {
				return err
			}
		}
		return nil
	}

	if len(a.defaultValues) > 0 {
		for _, defaultValue := range a.defaultValues {
			if err := a.value.Set(defaultValue); err != nil {
				return err
			}
		}
		return nil
	}

	return nil
}

func (a *ArgClause) needsValue() bool {
	haveDefault := len(a.defaultValues) > 0
	return a.required && !(haveDefault || a.HasEnvarValue())
}

func (a *ArgClause) consumesRemainder() bool {
	if r, ok := a.value.(remainderArg); ok {
		return r.IsCumulative()
	}
	return false
}

// Required arguments must be input by the user. They can not have a Default() value provided.
func (a *ArgClause) Required() *ArgClause {
	a.required = true
	return a
}

// Default values for this argument. They *must* be parseable by the value of the argument.
func (a *ArgClause) Default(values ...string) *ArgClause {
	a.defaultValues = values
	return a
}

// Envar overrides the default value(s) for a flag from an environment variable,
// if it is set. Several default values can be provided by using new lines to
// separate them.
func (a *ArgClause) Envar(name string) *ArgClause {
	a.envar = name
	a.noEnvar = false
	return a
}

// NoEnvar forces environment variable defaults to be disabled for this flag.
// Most useful in conjunction with app.DefaultEnvars().
func (a *ArgClause) NoEnvar() *ArgClause {
	a.envar = ""
	a.noEnvar = true
	return a
}

func (a *ArgClause) Action(action Action) *ArgClause {
	a.addAction(action)
	return a
}

func (a *ArgClause) PreAction(action Action) *ArgClause {
	a.addPreAction(action)
	return a
}

// HintAction registers a HintAction (function) for the arg to provide completions
func (a *ArgClause) HintAction(action HintAction) *ArgClause {
	a.addHintAction(action)
	return a
}

// HintOptions registers any number of options for the flag to provide completions
func (a *ArgClause) HintOptions(options ...string) *ArgClause {
	a.addHintAction(func() []string {
		return options
	})
	return a
}

func (a *ArgClause) init() error {
	if a.required && len(a.defaultValues) > 0 {
		return fmt.Errorf("required argument '%s' with unusable default value", a.name)
	}
	if a.value == nil {
		return fmt.Errorf("no parser defined for arg '%s'", a.name)
	}
	return nil
}