package opts

 
 import (
 	"fmt"

 	"math/big"

 	"net"

 	"regexp"

 	"strings"

 	"github.com/docker/docker/api/types/filters"

 )
 

 var (

 	alphaRegexp  = regexp.MustCompile(`[a-zA-Z]`)
 	domainRegexp = regexp.MustCompile(`^(:?(:?[a-zA-Z0-9]|(:?[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]))(:?\.(:?[a-zA-Z0-9]|(:?[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])))*)\.?\s*$`)

 )
 

 // ListOpts holds a list of values and a validation function.

 type ListOpts struct {

 	values    *[]string

 	validator ValidatorFctType
 }
 

 // NewListOpts creates a new ListOpts with the specified validator.

 func NewListOpts(validator ValidatorFctType) ListOpts {

 	var values []string

 	return *NewListOptsRef(&values, validator)

 }
 

 // NewListOptsRef creates a new ListOpts with the specified values and validator.

 func NewListOptsRef(values *[]string, validator ValidatorFctType) *ListOpts {

 	return &ListOpts{
 		values:    values,

 		validator: validator,
 	}
 }
 
 func (opts *ListOpts) String() string {

 	return fmt.Sprintf("%v", []string((*opts.values)))

 }
 

 // Set validates if needed the input value and adds it to the

 // internal slice.
 func (opts *ListOpts) Set(value string) error {
 	if opts.validator != nil {
 		v, err := opts.validator(value)
 		if err != nil {
 			return err
 		}
 		value = v
 	}

 	(*opts.values) = append((*opts.values), value)

 	return nil
 }
 

 // Delete removes the specified element from the slice.

 func (opts *ListOpts) Delete(key string) {

 	for i, k := range *opts.values {

 		if k == key {

 			(*opts.values) = append((*opts.values)[:i], (*opts.values)[i+1:]...)

 			return
 		}
 	}
 }
 
 // GetMap returns the content of values in a map in order to avoid
 // duplicates.
 func (opts *ListOpts) GetMap() map[string]struct{} {
 	ret := make(map[string]struct{})

 	for _, k := range *opts.values {

 		ret[k] = struct{}{}
 	}
 	return ret
 }
 

 // GetAll returns the values of slice.

 func (opts *ListOpts) GetAll() []string {

 	return (*opts.values)

 }
 

 // GetAllOrEmpty returns the values of the slice
 // or an empty slice when there are no values.
 func (opts *ListOpts) GetAllOrEmpty() []string {
 	v := *opts.values
 	if v == nil {
 		return make([]string, 0)
 	}
 	return v
 }
 

 // Get checks the existence of the specified key.

 func (opts *ListOpts) Get(key string) bool {

 	for _, k := range *opts.values {

 		if k == key {
 			return true
 		}
 	}
 	return false
 }
 
 // Len returns the amount of element in the slice.
 func (opts *ListOpts) Len() int {

 	return len((*opts.values))

 }
 

 // Type returns a string name for this Option type
 func (opts *ListOpts) Type() string {
 	return "list"
 }
 

 // NamedOption is an interface that list and map options
 // with names implement.
 type NamedOption interface {
 	Name() string
 }
 
 // NamedListOpts is a ListOpts with a configuration name.
 // This struct is useful to keep reference to the assigned
 // field name in the internal configuration struct.
 type NamedListOpts struct {
 	name string
 	ListOpts
 }
 
 var _ NamedOption = &NamedListOpts{}
 
 // NewNamedListOptsRef creates a reference to a new NamedListOpts struct.
 func NewNamedListOptsRef(name string, values *[]string, validator ValidatorFctType) *NamedListOpts {
 	return &NamedListOpts{
 		name:     name,
 		ListOpts: *NewListOptsRef(values, validator),
 	}
 }
 
 // Name returns the name of the NamedListOpts in the configuration.
 func (o *NamedListOpts) Name() string {
 	return o.name
 }
 

 // MapOpts holds a map of values and a validation function.

 type MapOpts struct {
 	values    map[string]string
 	validator ValidatorFctType
 }
 

 // Set validates if needed the input value and add it to the
 // internal map, by splitting on '='.

 func (opts *MapOpts) Set(value string) error {
 	if opts.validator != nil {
 		v, err := opts.validator(value)
 		if err != nil {
 			return err
 		}
 		value = v
 	}
 	vals := strings.SplitN(value, "=", 2)
 	if len(vals) == 1 {
 		(opts.values)[vals[0]] = ""
 	} else {
 		(opts.values)[vals[0]] = vals[1]
 	}
 	return nil
 }
 

 // GetAll returns the values of MapOpts as a map.

 func (opts *MapOpts) GetAll() map[string]string {
 	return opts.values
 }
 

 func (opts *MapOpts) String() string {
 	return fmt.Sprintf("%v", map[string]string((opts.values)))
 }
 

 // Type returns a string name for this Option type
 func (opts *MapOpts) Type() string {
 	return "map"
 }
 

 // NewMapOpts creates a new MapOpts with the specified map of values and a validator.

 func NewMapOpts(values map[string]string, validator ValidatorFctType) *MapOpts {
 	if values == nil {
 		values = make(map[string]string)
 	}

 	return &MapOpts{
 		values:    values,
 		validator: validator,
 	}
 }
 

 // NamedMapOpts is a MapOpts struct with a configuration name.
 // This struct is useful to keep reference to the assigned
 // field name in the internal configuration struct.
 type NamedMapOpts struct {
 	name string
 	MapOpts
 }
 
 var _ NamedOption = &NamedMapOpts{}
 
 // NewNamedMapOpts creates a reference to a new NamedMapOpts struct.
 func NewNamedMapOpts(name string, values map[string]string, validator ValidatorFctType) *NamedMapOpts {
 	return &NamedMapOpts{
 		name:    name,
 		MapOpts: *NewMapOpts(values, validator),
 	}
 }
 
 // Name returns the name of the NamedMapOpts in the configuration.
 func (o *NamedMapOpts) Name() string {
 	return o.name
 }
 

 // ValidatorFctType defines a validator function that returns a validated string and/or an error.

 type ValidatorFctType func(val string) (string, error)

 // ValidatorFctListType defines a validator function that returns a validated list of string and/or an error

 type ValidatorFctListType func(val string) ([]string, error)

 // ValidateIPAddress validates an Ip address.

 func ValidateIPAddress(val string) (string, error) {

 	var ip = net.ParseIP(strings.TrimSpace(val))
 	if ip != nil {
 		return ip.String(), nil

 	}

 	return "", fmt.Errorf("%s is not an ip address", val)

 }

 // ValidateDNSSearch validates domain for resolvconf search configuration.
 // A zero length domain is represented by a dot (.).

 func ValidateDNSSearch(val string) (string, error) {

 	if val = strings.Trim(val, " "); val == "." {
 		return val, nil
 	}
 	return validateDomain(val)
 }
 
 func validateDomain(val string) (string, error) {

 	if alphaRegexp.FindString(val) == "" {

 		return "", fmt.Errorf("%s is not a valid domain", val)
 	}

 	ns := domainRegexp.FindSubmatch([]byte(val))

 	if len(ns) > 0 && len(ns[1]) < 255 {

 		return string(ns[1]), nil
 	}
 	return "", fmt.Errorf("%s is not a valid domain", val)
 }

 // ValidateLabel validates that the specified string is a valid label, and returns it.
 // Labels are in the form on key=value.

 func ValidateLabel(val string) (string, error) {

 	if strings.Count(val, "=") < 1 {

 		return "", fmt.Errorf("bad attribute format: %s", val)
 	}
 	return val, nil
 }

 // ValidateSysctl validates a sysctl and returns it.

 func ValidateSysctl(val string) (string, error) {
 	validSysctlMap := map[string]bool{
 		"kernel.msgmax":          true,
 		"kernel.msgmnb":          true,
 		"kernel.msgmni":          true,
 		"kernel.sem":             true,
 		"kernel.shmall":          true,
 		"kernel.shmmax":          true,
 		"kernel.shmmni":          true,
 		"kernel.shm_rmid_forced": true,
 	}
 	validSysctlPrefixes := []string{
 		"net.",
 		"fs.mqueue.",
 	}
 	arr := strings.Split(val, "=")
 	if len(arr) < 2 {
 		return "", fmt.Errorf("sysctl '%s' is not whitelisted", val)
 	}
 	if validSysctlMap[arr[0]] {
 		return val, nil
 	}
 
 	for _, vp := range validSysctlPrefixes {
 		if strings.HasPrefix(arr[0], vp) {
 			return val, nil
 		}
 	}
 	return "", fmt.Errorf("sysctl '%s' is not whitelisted", val)
 }

 
 // FilterOpt is a flag type for validating filters
 type FilterOpt struct {
 	filter filters.Args
 }
 
 // NewFilterOpt returns a new FilterOpt
 func NewFilterOpt() FilterOpt {
 	return FilterOpt{filter: filters.NewArgs()}
 }
 
 func (o *FilterOpt) String() string {
 	repr, err := filters.ToParam(o.filter)
 	if err != nil {
 		return "invalid filters"
 	}
 	return repr
 }
 
 // Set sets the value of the opt by parsing the command line value
 func (o *FilterOpt) Set(value string) error {
 	var err error
 	o.filter, err = filters.ParseFlag(value, o.filter)
 	return err
 }
 
 // Type returns the option type
 func (o *FilterOpt) Type() string {
 	return "filter"
 }
 
 // Value returns the value of this option
 func (o *FilterOpt) Value() filters.Args {
 	return o.filter
 }

 
 // NanoCPUs is a type for fixed point fractional number.
 type NanoCPUs int64
 
 // String returns the string format of the number
 func (c *NanoCPUs) String() string {
 	return big.NewRat(c.Value(), 1e9).FloatString(3)
 }
 
 // Set sets the value of the NanoCPU by passing a string
 func (c *NanoCPUs) Set(value string) error {

 	cpus, err := ParseCPUs(value)
 	*c = NanoCPUs(cpus)
 	return err

 }
 
 // Type returns the type
 func (c *NanoCPUs) Type() string {

 	return "decimal"

 }
 
 // Value returns the value in int64
 func (c *NanoCPUs) Value() int64 {
 	return int64(*c)
 }

 
 // ParseCPUs takes a string ratio and returns an integer value of nano cpus
 func ParseCPUs(value string) (int64, error) {
 	cpu, ok := new(big.Rat).SetString(value)
 	if !ok {
 		return 0, fmt.Errorf("failed to parse %v as a rational number", value)
 	}
 	nano := cpu.Mul(cpu, big.NewRat(1e9, 1))
 	if !nano.IsInt() {
 		return 0, fmt.Errorf("value is too precise")
 	}
 	return nano.Num().Int64(), nil
 }