package k8supgrade

import "fmt"

const (
	// aws
	ManagedNodeGroupMaxSkewVersion     = 2
	SelfManagedNodeGroupMaxSkewVersion = 2

	// gcp
	NodePoolMaxSkewVersion = 2
)

type Version struct {
	// Major is the major version of the component.
	Major int `json:"major"`
	// Minor is the minor version of the component.
	Minor int `json:"minor"`
}

func NewMustVersion(v string) Version {
	var ver Version
	if v == "" {
		return ver
	}
	_, _ = fmt.Sscanf(v, "%d.%d", &ver.Major, &ver.Minor)
	return ver
}

func (v *Version) String() string {
	return fmt.Sprintf("%d.%d", v.Major, v.Minor)
}

func (v *Version) LessThan(other Version) bool {
	return v.Major < other.Major || (v.Major == other.Major && v.Minor < other.Minor)
}

func (v *Version) GreaterThan(other Version) bool {
	return v.Major > other.Major || (v.Major == other.Major && v.Minor > other.Minor)
}

func (v *Version) Equal(other Version) bool {
	return v.Major == other.Major && v.Minor == other.Minor
}

func (v *Version) LessThanOrEqual(other Version) bool {
	return v.LessThan(other) || v.Equal(other)
}

func (v *Version) GreaterThanOrEqual(other Version) bool {
	return v.GreaterThan(other) || v.Equal(other)
}

func (v *Version) IncrementMinor(m int) Version {
	return Version{
		Major: v.Major,
		Minor: v.Minor + m,
	}
}

func (v *Version) DecrementMinor(m int) Version {
	return Version{
		Major: v.Major,
		Minor: v.Minor - m,
	}
}

func (v *Version) Copy() Version {
	return Version{
		Major: v.Major,
		Minor: v.Minor,
	}
}

func (v *Version) Sub(other Version) int {
	return (v.Major-other.Major)*100 + (v.Minor - other.Minor)
}

func FindMinimalVersion(versions ...Version) Version {
	if len(versions) == 0 {
		return Version{}
	}
	ret := versions[0]
	for _, v := range versions {
		if v.LessThan(ret) {
			ret = v
		}
	}
	return ret
}

func AreAllVersionsEqual(versions ...Version) bool {
	for i := 1; i < len(versions); i++ {
		if !versions[i].Equal(versions[0]) {
			return false
		}
	}
	return true
}