package envconf

import (
	"encoding/hex"
	"errors"
	"fmt"
	"os"
	"path"
	"strconv"
	"strings"
	"time"
)

func parseInt(key string, str string) (ret cValue) {
	val, err := strconv.ParseInt(str, 10, 64)
	if err == nil {
		ret.intval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type int.`, key))
	}
	return
}

func parseMetric(key string, str string) (ret cValue) {
	mod := int64(1)
	str = strings.ToUpper(str)
	if strings.HasSuffix(str, "K") {
		mod = 1024
		str = strings.TrimSuffix(str, "K")
	} else if strings.HasSuffix(str, "M") {
		mod = 1024 * 1024
		str = strings.TrimSuffix(str, "M")
	} else if strings.HasSuffix(str, "G") {
		mod = 1024 * 1024 * 1024
		str = strings.TrimSuffix(str, "G")
	} else if strings.HasSuffix(str, "T") {
		mod = 1024 * 1024 * 1024 * 1024
		str = strings.TrimSuffix(str, "T")
	}
	val, err := strconv.ParseInt(str, 10, 64)
	if err == nil {
		ret.intval = mod * val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type int.`, key))
	}
	return
}

func parseDuration(key string, str string) (ret cValue) {
	val, err := time.ParseDuration(str)
	if err == nil {
		ret.durval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type duration.`, key))
	}
	return
}

func parseBool(key string, str string) (ret cValue) {
	val, err := strconv.ParseBool(str)
	if err == nil {
		ret.boolval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type bool.`, key))
	}
	return
}

func parseHex(key string, str string) (ret cValue) {
	val, err := hex.DecodeString(str)
	if err == nil {
		ret.binval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type hex.`, key))
	}
	return
}

func parseHex16(key string, str string) (ret cValue) {
	val, err := hex.DecodeString(str)
	if err == nil && len(val) == 16 {
		ret.binval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type hex16.`, key))
	}
	return
}

func parseHex32(key string, str string) (ret cValue) {
	val, err := hex.DecodeString(str)
	if err == nil && len(val) == 32 {
		ret.binval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type hex32.`, key))
	}
	return
}

func parseHex64(key string, str string) (ret cValue) {
	val, err := hex.DecodeString(str)
	if err == nil && len(val) == 64 {
		ret.binval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type hex64.`, key))
	}
	return
}

func parseHex128(key string, str string) (ret cValue) {
	val, err := hex.DecodeString(str)
	if err == nil && len(val) == 128 {
		ret.binval = val
	} else {
		ret.err = errors.New(fmt.Sprintf(`Environment variable "%s" is not of type hex128.`, key))
	}
	return
}

func parseDirectory(_ string, str string) (ret cValue) {
	wd, err := os.Getwd()
	if err == nil {
		if path.IsAbs(str) {
			ret.strval = path.Clean(str)
		} else {
			ret.strval = path.Join(wd, str)
		}
	} else {
		ret.strval = path.Clean(str)
	}
	return
}

func parseString(_ string, str string) (ret cValue) {
	ret.strval = str
	return
}