// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gps

import "testing"

func TestVersionSorts(t *testing.T) {
	rev := Revision("flooboofoobooo")
	v1 := NewBranch("master").Pair(rev)
	v2 := NewBranch("test").Pair(rev)
	v3 := NewVersion("1.0.0").Pair(rev)
	v4 := NewVersion("1.0.1").Pair(rev)
	v5 := NewVersion("v2.0.5").Pair(rev)
	v6 := NewVersion("2.0.5.2").Pair(rev)
	v7 := newDefaultBranch("unwrapped").Pair(rev)
	v8 := NewVersion("20.0.5.2").Pair(rev)
	v9 := NewVersion("v1.5.5-beta.4").Pair(rev)
	v10 := NewVersion("v3.0.1-alpha.1").Pair(rev)

	start := []Version{
		v1,
		v2,
		v3,
		v4,
		v5,
		v6,
		v7,
		v8,
		v9,
		v10,
		rev,
	}

	down := make([]Version, len(start))
	copy(down, start)
	up := make([]Version, len(start))
	copy(up, start)

	edown := []Version{
		v3, v4, v5, // semvers
		v9, v10, // prerelease semver
		v7, v1, v2, // floating/branches
		v6, v8, // plain versions
		rev, // revs
	}

	eup := []Version{
		v5, v4, v3, // semvers
		v10, v9, // prerelease semver
		v7, v1, v2, // floating/branches
		v6, v8, // plain versions
		rev, // revs
	}

	SortForUpgrade(up)
	var wrong []int
	for k, v := range up {
		if eup[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on upgrade sort, but got %s", eup[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Upgrade sort positions with wrong versions: %v", wrong)
	}

	SortForDowngrade(down)
	wrong = wrong[:0]
	for k, v := range down {
		if edown[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on downgrade sort, but got %s", edown[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Downgrade sort positions with wrong versions: %v", wrong)
	}

	// Now make sure we sort back the other way correctly...just because
	SortForUpgrade(down)
	wrong = wrong[:0]
	for k, v := range down {
		if eup[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on down-then-upgrade sort, but got %s", eup[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Down-then-upgrade sort positions with wrong versions: %v", wrong)
	}

	// Now make sure we sort back the other way correctly...just because
	SortForDowngrade(up)
	wrong = wrong[:0]
	for k, v := range up {
		if edown[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on up-then-downgrade sort, but got %s", edown[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Fatalf("Up-then-downgrade sort positions with wrong versions: %v", wrong)
	}

	///////////
	// Repeat for PairedVersion slices & sorts

	pdown, pup := make([]PairedVersion, 0, len(start)), make([]PairedVersion, 0, len(start))
	for _, v := range start {
		if _, ok := v.(Revision); ok {
			continue
		}
		pdown = append(pdown, v.(PairedVersion))
		pup = append(pup, v.(PairedVersion))
	}

	pedown, peup := make([]PairedVersion, 0, len(edown)), make([]PairedVersion, 0, len(eup))
	for _, v := range edown {
		if _, ok := v.(Revision); ok {
			continue
		}
		pedown = append(pedown, v.(PairedVersion))
	}
	for _, v := range eup {
		if _, ok := v.(Revision); ok {
			continue
		}
		peup = append(peup, v.(PairedVersion))
	}

	SortPairedForUpgrade(pup)
	for k, v := range pup {
		if peup[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on upgrade sort, but got %s", peup[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Upgrade sort positions with wrong versions: %v", wrong)
	}

	SortPairedForDowngrade(pdown)
	wrong = wrong[:0]
	for k, v := range pdown {
		if pedown[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on downgrade sort, but got %s", pedown[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Downgrade sort positions with wrong versions: %v", wrong)
	}

	// Now make sure we sort back the other way correctly...just because
	SortPairedForUpgrade(pdown)
	wrong = wrong[:0]
	for k, v := range pdown {
		if peup[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on down-then-upgrade sort, but got %s", peup[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Down-then-upgrade sort positions with wrong versions: %v", wrong)
	}

	// Now make sure we sort back the other way correctly...just because
	SortPairedForDowngrade(pup)
	wrong = wrong[:0]
	for k, v := range pup {
		if pedown[k] != v {
			wrong = append(wrong, k)
			t.Errorf("Expected version %s in position %v on up-then-downgrade sort, but got %s", pedown[k], k, v)
		}
	}
	if len(wrong) > 0 {
		// Just helps with readability a bit
		t.Errorf("Up-then-downgrade sort positions with wrong versions: %v", wrong)
	}
}