package forms

import (
	"context"
	"errors"
	"fmt"
	"net"
	"net/http"
	"net/mail"
	"strings"
	"unicode/utf8"
)

/* validation errors */
var (
	EInvalidInteger = errors.New("not a valid integer value")
	EInvalidFloat   = errors.New("not a valid float value")
	ERequired       = errors.New("this field is required")
)

/* A globaly defined set with valid domain TLDs */
var validTLDs = map[string]struct{}{
	/* general purpose domain names */
	"aero": {}, "asia": {}, "biz": {}, "cat": {}, "com": {}, "coop": {}, "info": {}, "int": {}, "jobs": {},
	"mobi": {}, "museum": {}, "name": {}, "net": {}, "org": {}, "pro": {}, "tel": {}, "travel": {}, "xxx": {},
	"edu": {}, "gov": {}, "mil": {},
	/* country code domain names */
	"ac": {}, "ad": {}, "ae": {}, "af": {}, "ag": {}, "ai": {}, "al": {}, "am": {}, "an": {}, "ao": {}, "aq": {},
	"ar": {}, "as": {}, "at": {}, "au": {}, "aw": {}, "ax": {}, "az": {}, "ba": {}, "bb": {}, "bd": {}, "be": {},
	"bf": {}, "bg": {}, "bh": {}, "bi": {}, "bj": {}, "bm": {}, "bn": {}, "bo": {}, "br": {}, "bs": {}, "bt": {},
	"bv": {}, "bw": {}, "by": {}, "bz": {}, "ca": {}, "cc": {}, "cd": {}, "cf": {}, "cg": {}, "ch": {}, "ci": {},
	"ck": {}, "cl": {}, "cm": {}, "cn": {}, "co": {}, "cr": {}, "cs": {}, "cu": {}, "cv": {}, "cx": {}, "cy": {},
	"cz": {}, "dd": {}, "de": {}, "dj": {}, "dk": {}, "dm": {}, "do": {}, "dz": {}, "ec": {}, "ee": {}, "eg": {},
	"eh": {}, "er": {}, "es": {}, "et": {}, "eu": {}, "fi": {}, "fj": {}, "fk": {}, "fm": {}, "fo": {}, "fr": {},
	"ga": {}, "gb": {}, "gd": {}, "ge": {}, "gf": {}, "gg": {}, "gh": {}, "gi": {}, "gl": {}, "gm": {}, "gn": {},
	"gp": {}, "gq": {}, "gr": {}, "gs": {}, "gt": {}, "gu": {}, "gw": {}, "gy": {}, "hk": {}, "hm": {}, "hn": {},
	"hr": {}, "ht": {}, "hu": {}, "id": {}, "ie": {}, "il": {}, "im": {}, "in": {}, "io": {}, "iq": {}, "ir": {},
	"is": {}, "it": {}, "je": {}, "jm": {}, "jo": {}, "jp": {}, "ke": {}, "kg": {}, "kh": {}, "ki": {}, "km": {},
	"kn": {}, "kp": {}, "kr": {}, "kw": {}, "ky": {}, "kz": {}, "la": {}, "lb": {}, "lc": {}, "li": {}, "lk": {},
	"lr": {}, "ls": {}, "lt": {}, "lu": {}, "lv": {}, "ly": {}, "ma": {}, "mc": {}, "md": {}, "me": {}, "mg": {},
	"mh": {}, "mk": {}, "ml": {}, "mm": {}, "mn": {}, "mo": {}, "mp": {}, "mq": {}, "mr": {}, "ms": {}, "mt": {},
	"mu": {}, "mv": {}, "mw": {}, "mx": {}, "my": {}, "mz": {}, "na": {}, "nc": {}, "ne": {}, "nf": {}, "ng": {},
	"ni": {}, "nl": {}, "no": {}, "np": {}, "nr": {}, "nu": {}, "nz": {}, "om": {}, "pa": {}, "pe": {}, "pf": {},
	"pg": {}, "ph": {}, "pk": {}, "pl": {}, "pm": {}, "pn": {}, "pr": {}, "ps": {}, "pt": {}, "pw": {}, "py": {},
	"qa": {}, "re": {}, "ro": {}, "rs": {}, "ru": {}, "rw": {}, "sa": {}, "sb": {}, "sc": {}, "sd": {}, "se": {},
	"sg": {}, "sh": {}, "si": {}, "sj": {}, "sk": {}, "sl": {}, "sm": {}, "sn": {}, "so": {}, "sr": {}, "ss": {},
	"st": {}, "su": {}, "sv": {}, "sy": {}, "sz": {}, "tc": {}, "td": {}, "tf": {}, "tg": {}, "th": {}, "tj": {},
	"tk": {}, "tl": {}, "tm": {}, "tn": {}, "to": {}, "tp": {}, "tr": {}, "tt": {}, "tv": {}, "tw": {}, "tz": {},
	"ua": {}, "ug": {}, "uk": {}, "us": {}, "uy": {}, "uz": {}, "va": {}, "vc": {}, "ve": {}, "vg": {}, "vi": {},
	"vn": {}, "vu": {}, "wf": {}, "ws": {}, "ye": {}, "yt": {}, "yu": {}, "za": {}, "zm": {}, "zw": {},
}

/* ValidLettersGeneric is a validator generator for checking for valid letters in field */
func ValidLettersGeneric(Letters string, Error error) ValidatorFunc {
	Callback := func(field *FormField, ctx context.Context) error {
		for _, Rune := range field.GetString() {
			if strings.IndexRune(Letters, Rune) == -1 {
				return Error
			}
		}
		return nil
	}
	return Callback
}

/* ValidLength makes sure that a string length is between specified vMin and vMax values. */
func ValidLength(vMin, vMax int, err error) ValidatorFunc {
	ELength := fmt.Errorf("must be a string between %d and %d characters in length", vMin, vMax)
	return func(field *FormField, ctx context.Context) error {
		if len(field.GetString()) != 0 && (len(field.GetString()) < vMin || len(field.GetString()) > vMax) {
			return fallbackError(err, ELength)
		}
		return nil
	}
}

/* ValidFieldIn verifies if item is within the list of items */
func ValidFieldIn(list []string, err error) ValidatorFunc {
	EInvalidValue := fmt.Errorf("field value must be one of: %s", strings.Join(list, ","))
	return func(field *FormField, ctx context.Context) error {
		for _, item := range list {
			if item == field.GetString() {
				return nil
			}
		}
		return fallbackError(err, EInvalidValue)
	}
}

/* ValidInt returns error if field does not contain a valid integer value */
func ValidInt(field *FormField, ctx context.Context) error {
	_, err := field.GetInt()
	if err != nil {
		return EInvalidInteger
	}
	return nil
}

/* ValidBetween makes sure that field is integer value within the specified range. */
func ValidBetween(minV, maxV int, err error) ValidatorFunc {
	var EInvalidInterval = fmt.Errorf("must be integer between %d and %d", minV, maxV)
	return func(field *FormField, ctx context.Context) error {
		if value, err := field.GetInt(); err != nil || (value < minV || value > maxV) {
			return fallbackError(err, EInvalidInterval)
		}
		return nil
	}
}

/* ValidFloat returns error if field does not contain a valid integer value */
func ValidFloat(field *FormField, ctx context.Context) error {
	_, err := field.GetFloat()
	if err != nil {
		return EInvalidFloat
	}
	return nil
}

/* ValidBetweenFloat32 makes sure field is float64 value within the specified range. */
func ValidBetweenFloat(min, max float64) ValidatorFunc {
	var EInvalidInterval = errors.New(
		fmt.Sprintf("must be float value between %.2f and %.2f", min, max))
	return func(field *FormField, ctx context.Context) error {
		value, err := field.GetFloat()
		if err != nil {
			return err
		}
		if value < min || value > max {
			return EInvalidInterval
		}
		return nil
	}
}

/* ValidFieldEqualTo is a validator that checks if two fields have the same value. */
func ValidFieldEqualTo(other *FormField, err error) ValidatorFunc {
	defaultErr := errors.New("The text field must match other field's text exactly")
	return func(field *FormField, ctx context.Context) error {
		if field.GetString() != other.GetString() {
			return fallbackError(err, defaultErr)
		}
		return nil
	}
}

/* ValidExct checks if text field has exact value */
func ValidExact(text string, err error) ValidatorFunc {
	defaultErr := fmt.Errorf("The the text field must be exactly '%s'", text)
	return func(field *FormField, ctx context.Context) error {
		if field.GetString() != text {
			return fallbackError(err, defaultErr)
		}
		return nil
	}
}

/* validHostnameStr performs checks if the hostname name stored in *FormField is valid */
func validHostnameStr(minLevel int, err error) func(string) error {
	EInvalidHostname := errors.New("invalid hostname")
	return func(hostname string) error {
		hostname = strings.ToLower(strings.TrimSpace(hostname))
		hostnameLen := len(hostname)
		/* common hostname name checks */
		if hostnameLen == 0 || hostnameLen > 253 || strings.ContainsAny(hostname, " \t\r\n") {
			return fallbackError(err, EInvalidHostname)
		}
		if hostname[0] == '.' {
			return fallbackError(err, EInvalidHostname)
		}
		/* make sure hostname name only contains allowed letters */
		for _, r := range hostname {
			if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '.' || r == '-' {
				continue
			}
			return fallbackError(err, EInvalidHostname)
		}
		/* split to levels (tld, hostname[, subhostname...] */
		levels := strings.Split(hostname, ".")
		if len(levels) < minLevel {
			return fallbackError(err, EInvalidHostname)
		}
		/* perform common checks on levels */
		for _, level := range levels {
			levelLen := len(level)
			if levelLen == 0 {
				continue
			}
			if levelLen > 63 {
				return fallbackError(err, EInvalidHostname)
			}
			if level[0] == '-' || level[levelLen-1] == '-' {
				return fallbackError(err, EInvalidHostname)
			}

		}
		/* make sure hostname is not an IP address */
		if ip := net.ParseIP(hostname); ip != nil {
			return fallbackError(err, EInvalidHostname)
		}
		return nil
	}
}

/* ValidHostname performs basic hostname checks */
func ValidHostname(err error) ValidatorFunc {
	callbackCheck := validHostnameStr(0, err)
	/* hostname name checks */
	return func(field *FormField, ctx context.Context) error {
		return callbackCheck(field.GetString())
	}
}

/* ValidDomainName performs basic domain name checks */
func ValidDomainName(err error) ValidatorFunc {
	callbackCheck := validHostnameStr(2, err)
	/* domain name checks */
	return func(field *FormField, ctx context.Context) error {
		return callbackCheck(field.GetString())
	}
}

/* ValidDomainNameTLD checks if a field in a domain name has a whitelisted TLD */
func ValidDomainNameTLD(err error) ValidatorFunc {
	EInvalidDomainTLD := errors.New("invalid domain TLD")
	return func(field *FormField, ctx context.Context) error {
		/* make sure tld has proper size and is whitelisted */
		domain := strings.ToLower(strings.TrimSpace(field.GetString()))
		levels := strings.Split(domain, ".")
		domainTLD := levels[len(levels)-1]
		if len(domainTLD) < 2 {
			return fallbackError(err, EInvalidDomainTLD)
		}
		if _, ok := validTLDs[domainTLD]; !ok {
			return fallbackError(err, EInvalidDomainTLD)
		}
		return nil
	}
}

/* ValidEmailLocal checks a valid local part for email address */
func ValidEmailLocal(err error) ValidatorFunc {
	EInvalidEmail := errors.New("invalid email address")
	validLetters := ValidLettersGeneric(
		"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ._-+",
		fallbackError(err, EInvalidEmail),
	)
	return func(field *FormField, ctx context.Context) error {
		/* check for allowed symbols in local part */
		if err := validLetters(field, ctx); err != nil {
			return err
		}
		/* common checks */
		local := field.GetString()
		if len(local) > 64 || local[0] == '.' || local[len(local)-1] == '.' || strings.Index(local, "..") != -1 {
			return fallbackError(err, EInvalidEmail)
		}
		return nil
	}
}

/* ValidEmail checks if field contains a valid email address */
func ValidEmail(err error) ValidatorFunc {
	EInvalidEmail := errors.New("invalid email address")
	domainValidator := validHostnameStr(2, nil)
	return func(field *FormField, ctx context.Context) error {
		/* sanitize input */
		addrStr := strings.TrimSpace(field.GetString())
		if addrStr == "" || !utf8.ValidString(addrStr) || strings.ContainsAny(addrStr, " \t\r\n") {
			return fallbackError(err, EInvalidEmail)
		}
		/* use mail.ParseAddress on the sanitized text */
		addr, err := mail.ParseAddress(addrStr)
		if err != nil || addr.Address != addrStr {
			return fallbackError(err, EInvalidEmail)
		}
		/* make sure email address has a valid domain name */
		domain := strings.SplitN(addrStr, "@", 2)[1]
		if err := domainValidator(domain); err != nil {
			return fallbackError(err, EInvalidEmail)
		}
		return nil
	}
}

/* ValidIP checks if field contains a valid network address */
func ValidIP(err error) ValidatorFunc {
	EInvalidAddress := errors.New("invalid network address")
	return func(field *FormField, ctx context.Context) error {
		if ip := net.ParseIP(field.GetString()); ip == nil {
			return fallbackError(err, EInvalidAddress)
		}
		return nil
	}
}

/* ValidIPv4 checks if field contains a valid IPv4 network address */
func ValidIPv4(err error) ValidatorFunc {
	EInvalidAddress := errors.New("invalid ipv4 address")
	return func(field *FormField, ctx context.Context) error {
		if ip := net.ParseIP(field.GetString()); ip == nil || ip.To4() == nil {
			return fallbackError(err, EInvalidAddress)
		}
		return nil
	}
}

/* ValidIPv6 checks if field contains a valid IPv6 network address */
func ValidIPv6(err error) ValidatorFunc {
	EInvalidAddress := errors.New("invalid ipv6 address")
	return func(field *FormField, ctx context.Context) error {
		if ip := net.ParseIP(field.GetString()); ip == nil || ip.To4() != nil {
			return fallbackError(err, EInvalidAddress)
		}
		return nil
	}
}

/* ValidCSRF checks if CSRF token is valid */
func ValidCSRF(r *http.Request) ValidatorFunc {
	return func(field *FormField, ctx context.Context) error {
		if !csrfVerify(r) {
			return EInvalidCSRF
		}
		return nil
	}
}