package opts

 
 import (
 	"fmt"

 	"net"

 	"os"

 	"path"

 	"regexp"

 	"strings"

 	"github.com/docker/docker/api"
 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/parsers"

 	"github.com/docker/docker/pkg/ulimit"

 	"github.com/docker/docker/utils"

 )
 

 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*$`)
 )
 

 func ListVar(values *[]string, names []string, usage string) {
 	flag.Var(newListOptsRef(values, nil), names, usage)
 }
 
 func HostListVar(values *[]string, names []string, usage string) {
 	flag.Var(newListOptsRef(values, api.ValidateHost), names, usage)
 }
 
 func IPListVar(values *[]string, names []string, usage string) {
 	flag.Var(newListOptsRef(values, ValidateIPAddress), names, usage)
 }
 
 func DnsSearchListVar(values *[]string, names []string, usage string) {
 	flag.Var(newListOptsRef(values, ValidateDnsSearch), names, usage)
 }
 
 func IPVar(value *net.IP, names []string, defaultValue, usage string) {
 	flag.Var(NewIpOpt(value, defaultValue), names, usage)
 }
 

 func LabelListVar(values *[]string, names []string, usage string) {
 	flag.Var(newListOptsRef(values, ValidateLabel), names, usage)
 }
 

 func UlimitMapVar(values map[string]*ulimit.Ulimit, names []string, usage string) {
 	flag.Var(NewUlimitOpt(values), names, usage)
 }
 

 // ListOpts type
 type ListOpts struct {

 	values    *[]string

 	validator ValidatorFctType
 }
 
 func NewListOpts(validator ValidatorFctType) ListOpts {

 	var values []string
 	return *newListOptsRef(&values, 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 add 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 remove the given 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.
 // FIXME: can we remove this?
 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' slice.
 // FIXME: Can we remove this?
 func (opts *ListOpts) GetAll() []string {

 	return (*opts.values)

 }
 
 // Get checks the existence of the given 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))

 }
 
 // Validators
 type ValidatorFctType func(val string) (string, error)

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

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

 	s := strings.ToLower(val)
 	for _, str := range []string{"stdin", "stdout", "stderr"} {
 		if s == str {
 			return s, nil
 		}

 	}

 	return val, fmt.Errorf("valid streams are STDIN, STDOUT and STDERR.")

 }
 
 func ValidateLink(val string) (string, error) {

 	if _, err := parsers.PartParser("name:alias", val); err != nil {

 		return val, err
 	}
 	return val, nil
 }
 
 func ValidatePath(val string) (string, error) {
 	var containerPath string
 

 	if strings.Count(val, ":") > 2 {
 		return val, fmt.Errorf("bad format for volumes: %s", val)
 	}
 

 	splited := strings.SplitN(val, ":", 2)
 	if len(splited) == 1 {
 		containerPath = splited[0]

 		val = path.Clean(splited[0])

 	} else {
 		containerPath = splited[1]

 		val = fmt.Sprintf("%s:%s", splited[0], path.Clean(splited[1]))

 	}
 

 	if !path.IsAbs(containerPath) {

 		return val, fmt.Errorf("%s is not an absolute path", containerPath)
 	}
 	return val, nil
 }
 
 func ValidateEnv(val string) (string, error) {
 	arr := strings.Split(val, "=")
 	if len(arr) > 1 {
 		return val, nil
 	}

 	if !utils.DoesEnvExist(val) {
 		return val, nil
 	}

 	return fmt.Sprintf("%s=%s", val, os.Getenv(val)), nil
 }
 

 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)

 }

 func ValidateMACAddress(val string) (string, error) {
 	_, err := net.ParseMAC(strings.TrimSpace(val))
 	if err != nil {
 		return "", err
 	} else {
 		return val, nil
 	}
 }
 

 // Validates domain for resolvconf search configuration.
 // A zero length domain is represented by .
 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)
 }

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

 	// allow for IPv6 addresses in extra hosts by only splitting on first ":"
 	arr := strings.SplitN(val, ":", 2)

 	if len(arr) != 2 || len(arr[0]) == 0 {

 		return "", fmt.Errorf("bad format for add-host: %q", val)

 	}
 	if _, err := ValidateIPAddress(arr[1]); err != nil {

 		return "", fmt.Errorf("invalid IP address in add-host: %q", arr[1])

 	}
 	return val, nil
 }
 

 func ValidateLabel(val string) (string, error) {
 	if strings.Count(val, "=") != 1 {
 		return "", fmt.Errorf("bad attribute format: %s", val)
 	}
 	return val, nil
 }