package sec

import (
	// stdlib
	"errors"
	"os"
	"reflect"
	"strconv"
)

var (
	errNotBool = errors.New("environment variable doesn't contain boolean")

	errNotFloat   = errors.New("environment variable doesn't contain floating point number")
	errNotFloat32 = errors.New("environment variable doesn't contain float32")
	errNotFloat64 = errors.New("environment variable doesn't contain float64")

	errNotInt   = errors.New("environment variable doesn't contain integer")
	errNotInt8  = errors.New("environment variable doesn't contain int8")
	errNotInt16 = errors.New("environment variable doesn't contain int16")
	errNotInt32 = errors.New("environment variable doesn't contain int32")
	errNotInt64 = errors.New("environment variable doesn't contain int64")

	errNotUint   = errors.New("environment variable doesn't contain unsigned integer")
	errNotUint8  = errors.New("environment variable doesn't contain uint8")
	errNotUint16 = errors.New("environment variable doesn't contain uint16")
	errNotUint32 = errors.New("environment variable doesn't contain uint32")
	errNotUint64 = errors.New("environment variable doesn't contain uint64")
)

// Parses environment for data.
func parseEnv() error {
	printDebug("Starting parsing data into tree from environment variables...")

	for _, element := range parsedTree {
		printDebug("Processing element '%s'", element.EnvVar)
		data, found := os.LookupEnv(element.EnvVar)
		if !found {
			printDebug("Value for '%s' environment variable wasn't found", element.EnvVar)
			continue
		} else {
			printDebug("Value for '%s' will be: %s", element.EnvVar, data)
		}

		switch element.Kind {
		case reflect.String:
			element.Pointer.SetString(data)
		case reflect.Bool:
			val, err := strconv.ParseBool(data)
			if err != nil {
				printDebug("Error occurred while parsing boolean: %s", err.Error())
				if options.ErrorsAreCritical {
					return errNotBool
				}
			}
			element.Pointer.SetBool(val)
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			// Bitsize 64 here specified for a reason - actual ints
			// ranges checking goes below and we should expect it to
			// be 0 in case of configuration.
			val, err := strconv.ParseInt(data, 10, 64)
			if err != nil {
				printDebug("Error occurred while parsing int: %s", err.Error())
				if options.ErrorsAreCritical {
					return errNotInt
				}
			}
			switch element.Kind {
			case reflect.Int8:
				// int8 is an integer in [-128...127] range.
				if val >= -128 && val <= 127 {
					element.Pointer.SetInt(val)
				} else {
					printDebug("Data in environment variable '%s' isn't int8", element.EnvVar)
					element.Pointer.SetInt(0)
					if options.ErrorsAreCritical {
						return errNotInt8
					}
				}
			case reflect.Int16:
				// int16 is an integer in [-32768...32767] range.
				if val >= -32768 && val <= 32767 {
					element.Pointer.SetInt(val)
				} else {
					printDebug("Data in environment variable '%s' isn't int16", element.EnvVar)
					element.Pointer.SetInt(0)
					if options.ErrorsAreCritical {
						return errNotInt16
					}
				}
			case reflect.Int32:
				// int32 is an integer in [-2147483648...2147483647] range.
				if val >= -2147483648 && val <= 2147483647 {
					element.Pointer.SetInt(val)
				} else {
					printDebug("Data in environment variable '%s' isn't int32", element.EnvVar)
					element.Pointer.SetInt(0)
					if options.ErrorsAreCritical {
						return errNotInt32
					}
				}
			case reflect.Int64, reflect.Int:
				// int64 is an integer in [-9223372036854775808...9223372036854775807] range.
				// This is currently maximum allowed int values, so we'll
				// just set it.
				element.Pointer.SetInt(val)
			}
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			val, err := strconv.ParseUint(data, 10, 64)
			if err != nil {
				printDebug("Error occurred while parsing unsigned integer: %s", err.Error())
				if options.ErrorsAreCritical {
					return errNotUint
				}
			}
			switch element.Kind {
			case reflect.Uint8:
				// uint8 is an integer in [0...255] range.
				if val <= 255 {
					element.Pointer.SetUint(val)
				} else {
					printDebug("Data in environment variable '%s' isn't uint8", element.EnvVar)
					element.Pointer.SetUint(0)
					if options.ErrorsAreCritical {
						return errNotUint8
					}
				}
			case reflect.Uint16:
				// uint16 is an integer in [0...65535] range.
				if val <= 65535 {
					element.Pointer.SetUint(val)
				} else {
					printDebug("Data in environment variable '%s' isn't uint16", element.EnvVar)
					element.Pointer.SetUint(0)
					if options.ErrorsAreCritical {
						return errNotUint16
					}
				}
			case reflect.Uint32:
				// uint32 is an integer in [0...4294967295] range.
				if val <= 4294967295 {
					element.Pointer.SetUint(val)
				} else {
					printDebug("Data in environment variable '%s' isn't uint32", element.EnvVar)
					element.Pointer.SetUint(0)
					if options.ErrorsAreCritical {
						return errNotUint32
					}
				}
			case reflect.Uint64:
				// uint64 is an integer in [0...18446744073709551615] range.
				// This is currently maximum allowed int values, so we'll
				// just set it.
				element.Pointer.SetUint(val)
			}
		case reflect.Float32, reflect.Float64:
			val, err := strconv.ParseFloat(data, 64)
			if err != nil {
				printDebug("Error occurred while parsing float: %s", err.Error())
				if options.ErrorsAreCritical {
					return errNotFloat
				}
			}
			element.Pointer.SetFloat(val)
		}
	}

	return nil
}