package argh

const (
	OneOrMoreValue  NValue = -2
	ZeroOrMoreValue NValue = -1
	ZeroValue       NValue = 0
)

var (
	POSIXyParserConfig = &ParserConfig{
		Prog:          CommandConfig{},
		ScannerConfig: POSIXyScannerConfig,
	}
)

type NValue int

func (nv NValue) Contains(i int) bool {
	if i < int(ZeroValue) {
		return false
	}

	if nv == OneOrMoreValue || nv == ZeroOrMoreValue {
		return true
	}

	return int(nv) > i
}

type ParserConfig struct {
	Prog CommandConfig

	ScannerConfig *ScannerConfig
}

type CommandConfig struct {
	NValue     NValue
	ValueNames []string
	Flags      *Flags
	Commands   *Commands
}

func (cCfg *CommandConfig) GetCommandConfig(name string) (CommandConfig, bool) {
	if cCfg.Commands == nil {
		cCfg.Commands = &Commands{Map: map[string]CommandConfig{}}
	}

	return cCfg.Commands.Get(name)
}

func (cCfg *CommandConfig) GetFlagConfig(name string) (FlagConfig, bool) {
	if cCfg.Flags == nil {
		cCfg.Flags = &Flags{Map: map[string]FlagConfig{}}
	}

	return cCfg.Flags.Get(name)
}

type FlagConfig struct {
	NValue     NValue
	Persist    bool
	ValueNames []string
}

type Flags struct {
	Parent *Flags
	Map    map[string]FlagConfig
}

func (fl *Flags) Get(name string) (FlagConfig, bool) {
	if fl.Map == nil {
		fl.Map = map[string]FlagConfig{}
	}

	flCfg, ok := fl.Map[name]
	if !ok && fl.Parent != nil {
		flCfg, ok = fl.Parent.Get(name)
		return flCfg, ok && flCfg.Persist
	}

	return flCfg, ok
}

type Commands struct {
	Map map[string]CommandConfig
}

func (cmd *Commands) Get(name string) (CommandConfig, bool) {
	tracef("Get(%q)", name)

	if cmd.Map == nil {
		cmd.Map = map[string]CommandConfig{}
	}

	cmdCfg, ok := cmd.Map[name]
	return cmdCfg, ok
}