package version

import (
	"errors"
	"fmt"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"unicode"
)

type defaultNumSlice []int

// get function returns 0, if the slice does not have the specified index.
func (n defaultNumSlice) get(i int) int {
	if len(n) > i {
		return n[i]
	}
	return 0
}

type defaultStringSlice []string

// get function returns "", if the slice does not have the specified index.
func (s defaultStringSlice) get(i int) string {
	if len(s) > i {
		return s[i]
	}
	return ""
}

// Version represents a package version (http://man.he.net/man5/deb-version).
type Version struct {
	epoch           int
	upstreamVersion string
	debianRevision  string
}

var (
	digitRegexp    = regexp.MustCompile(`[0-9]+`)
	nonDigitRegexp = regexp.MustCompile(`[^0-9]+`)
)

// NewVersion returns a parsed version
func NewVersion(ver string) (version Version, err error) {
	// Trim space
	ver = strings.TrimSpace(ver)

	// Parse epoch
	splitted := strings.SplitN(ver, ":", 2)
	if len(splitted) == 1 {
		version.epoch = 0
		ver = splitted[0]
	} else {
		version.epoch, err = strconv.Atoi(splitted[0])
		if err != nil {
			return Version{}, fmt.Errorf("epoch parse error: %v", err)
		}

		if version.epoch < 0 {
			return Version{}, errors.New("epoch is negative")
		}
		ver = splitted[1]
	}

	// Parse upstream_version and debian_revision
	index := strings.LastIndex(ver, "-")
	if index >= 0 {
		version.upstreamVersion = ver[:index]
		version.debianRevision = ver[index+1:]

	} else {
		version.upstreamVersion = ver
	}

	// Verify upstream_version is valid
	err = verifyUpstreamVersion(version.upstreamVersion)
	if err != nil {
		return Version{}, err
	}

	// Verify debian_revision is valid
	err = verifyDebianRevision(version.debianRevision)
	if err != nil {
		return Version{}, err
	}

	return version, nil
}

func verifyUpstreamVersion(str string) error {
	if len(str) == 0 {
		return errors.New("upstream_version is empty")
	}

	// The upstream-version should start with a digit
	if !unicode.IsDigit(rune(str[0])) {
		return errors.New("upstream_version must start with digit")
	}

	// The upstream-version may contain only alphanumerics("A-Za-z0-9") and the characters .+-:~
	allowedSymbols := ".-+~:_"
	for _, s := range str {
		if !unicode.IsDigit(s) && !unicode.IsLetter(s) && !strings.ContainsRune(allowedSymbols, s) {
			return errors.New("upstream_version includes invalid character")
		}
	}
	return nil
}

func verifyDebianRevision(str string) error {
	// The debian-revision may contain only alphanumerics and the characters +.~
	allowedSymbols := "+.~_"
	for _, s := range str {
		if !unicode.IsDigit(s) && !unicode.IsLetter(s) && !strings.ContainsRune(allowedSymbols, s) {
			return errors.New("debian_revision includes invalid character")
		}
	}
	return nil
}

// Equal returns whether this version is equal with another version.
func (v1 *Version) Equal(v2 Version) bool {
	return v1.Compare(v2) == 0
}

// GreaterThan returns whether this version is greater than another version.
func (v1 *Version) GreaterThan(v2 Version) bool {
	return v1.Compare(v2) > 0
}

// LessThan returns whether this version is less than another version.
func (v1 Version) LessThan(v2 Version) bool {
	return v1.Compare(v2) < 0
}

// Compare returns an integer comparing two version according to deb-version.
// The result will be 0 if v1==v2, -1 if v1 < v2, and +1 if v1 > v2.
func (v1 Version) Compare(v2 Version) int {
	// Equal
	if reflect.DeepEqual(v1, v2) {
		return 0
	}

	// Compare epochs
	if v1.epoch > v2.epoch {
		return 1
	} else if v1.epoch < v2.epoch {
		return -1
	}

	// Compare version
	ret := compare(v1.upstreamVersion, v2.upstreamVersion)
	if ret != 0 {
		return ret
	}

	//Compare debian_revision
	return compare(v1.debianRevision, v2.debianRevision)
}

// String returns the full version string
func (v1 Version) String() string {
	version := ""
	if v1.epoch > 0 {
		version += fmt.Sprintf("%d:", v1.epoch)
	}
	version += v1.upstreamVersion

	if v1.debianRevision != "" {
		version += fmt.Sprintf("-%s", v1.debianRevision)

	}
	return version
}

func compare(v1, v2 string) int {
	// Equal
	if v1 == v2 {
		return 0
	}

	// Extract digit strings and non-digit strings
	numbers1, strings1 := extract(v1)
	numbers2, strings2 := extract(v2)

	if len(v1) > 0 && unicode.IsDigit(rune(v1[0])) {
		strings1 = append([]string{""}, strings1...)
	}
	if len(v2) > 0 && unicode.IsDigit(rune(v2[0])) {
		strings2 = append([]string{""}, strings2...)
	}

	for i := 0; ; i++ {
		// Compare non-digit strings
		diff := compareString(strings1.get(i), strings2.get(i))
		if diff != 0 {
			return diff
		}

		// Compare digit strings
		diff = numbers1.get(i) - numbers2.get(i)
		if diff != 0 {
			return diff
		}
	}
}

func compareString(s1, s2 string) int {
	if s1 == s2 {
		return 0
	}

	for i := 0; ; i++ {
		a := 0
		if i < len(s1) {
			a = order(rune(s1[i]))
		}

		b := 0
		if i < len(s2) {
			b = order(rune(s2[i]))
		}

		if a != b {
			return a - b
		}
	}

}

// order function returns the number corresponding to rune
func order(r rune) int {
	// all the letters sort earlier than all the non-letters
	if unicode.IsLetter(r) {
		return int(r)
	}

	// a tilde sorts before anything
	if r == '~' {
		return -1
	}

	return int(r) + 256
}

func extract(version string) (defaultNumSlice, defaultStringSlice) {
	numbers := digitRegexp.FindAllString(version, -1)

	var dnum defaultNumSlice
	for _, number := range numbers {
		n, _ := strconv.Atoi(number)
		dnum = append(dnum, n)
	}

	s := nonDigitRegexp.FindAllString(version, -1)

	return dnum, defaultStringSlice(s)

}