package telegram

import (
	"testing"
)

// -x->[]-x-> +(.)
func TestSetMUCOccupantsLRUSetInitiallyEmpty(t *testing.T) {
	// init
	occupants := NewMUCOccupantsLRU()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(1, newOccupant)

	// checks
	if occupants.oldest != newOccupant || newOccupant.prev != nil || newOccupant.next != nil || occupants.newest != newOccupant {
		t.Error("Broken")
	}
}

func testMUCOccupantsLRUChainOfOne() (occupants *MUCOccupantsLRU, occupant1 *MUCOccupant) {
	occupants = NewMUCOccupantsLRU()
	occupant1 = &MUCOccupant{}
	occupants.m[1] = occupant1
	occupants.oldest = occupant1
	occupants.newest = occupant1

	return
}

func testMUCOccupantsLRUChainOfThree() (occupants *MUCOccupantsLRU, occupant1, occupant2, occupant3 *MUCOccupant) {
	occupants = NewMUCOccupantsLRU()
	occupant1 = &MUCOccupant{}
	occupant2 = &MUCOccupant{}
	occupant3 = &MUCOccupant{}
	occupants.m[1] = occupant1
	occupants.m[2] = occupant2
	occupants.m[3] = occupant3
	occupants.oldest = occupant1
	occupants.newest = occupant3
	occupant1.next = occupant2
	occupant2.prev = occupant1
	occupant2.next = occupant3
	occupant3.prev = occupant2

	return
}

// ->[]->()-> +(.)
func TestSetMUCOccupantsLRUSetOneOther(t *testing.T) {
	// init
	occupants, occupant1 := testMUCOccupantsLRUChainOfOne()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(2, newOccupant)

	// checks
	if occupants.oldest != occupant1 || occupant1.prev != nil || occupant1.next != newOccupant || newOccupant.prev != occupant1 || newOccupant.next != nil || occupants.newest != newOccupant {
		t.Error("Broken")
	}
}

// ->[]->()->()->()-> +(.)
func TestSetMUCOccupantsLRUSetThreeOthers(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(4, newOccupant)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant2 ||
		occupant2.prev != occupant1 ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != newOccupant ||
		newOccupant.prev != occupant3 ||
		newOccupant.next != nil ||
		occupants.newest != newOccupant {
		t.Error("Broken")
	}
}

// ->[]->(.)->()->()-> +(.)
func TestSetMUCOccupantsLRUSetReplaceFirst(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(1, newOccupant)

	// checks
	if occupants.oldest != occupant2 ||
		occupant2.prev != nil ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != newOccupant ||
		newOccupant.prev != occupant3 ||
		newOccupant.next != nil ||
		occupants.newest != newOccupant ||
		occupant1.prev != nil ||
		occupant1.next != nil {
		t.Error("Broken")
	}
}

// ->[]->()->(.)->()-> +(.)
func TestSetMUCOccupantsLRUSetReplaceMiddle(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(2, newOccupant)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant3 ||
		occupant3.prev != occupant1 ||
		occupant3.next != newOccupant ||
		newOccupant.prev != occupant3 ||
		newOccupant.next != nil ||
		occupants.newest != newOccupant ||
		occupant2.prev != nil ||
		occupant2.next != nil {
		t.Error("Broken")
	}
}

// ->[]->()->()->(.)-> +(.)
func TestSetMUCOccupantsLRUSetReplaceLast(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(3, newOccupant)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant2 ||
		occupant2.prev != occupant1 ||
		occupant2.next != newOccupant ||
		newOccupant.prev != occupant2 ||
		newOccupant.next != nil ||
		occupants.newest != newOccupant ||
		occupant3.prev != nil ||
		occupant3.next != nil {
		t.Error("Broken")
	}
}

// ->[]->(.)-> +(.)
func TestSetMUCOccupantsLRUSetReplaceOnly(t *testing.T) {
	// init
	occupants, occupant1 := testMUCOccupantsLRUChainOfOne()

	// addition
	newOccupant := &MUCOccupant{}
	occupants.Set(1, newOccupant)

	// checks
	if occupants.oldest != newOccupant ||
		occupants.newest != newOccupant ||
		newOccupant.prev != nil ||
		newOccupant.next != nil ||
		occupant1.prev != nil ||
		occupant1.next != nil {
		t.Error("Broken")
	}
}

// ->[]->(.)->()->()-> +s(.)
func TestSetMUCOccupantsLRUSetReplaceFirstWithSame(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	occupants.Set(1, occupant1)

	// checks
	if occupants.oldest != occupant2 ||
		occupant2.prev != nil ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != occupant1 ||
		occupant1.prev != occupant3 ||
		occupant1.next != nil ||
		occupants.newest != occupant1 {
		t.Error("Broken")
	}
}

// ->[]->()->(.)->()-> +s(.)
func TestSetMUCOccupantsLRUSetReplaceMiddleWithSame(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	occupants.Set(2, occupant2)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant3 ||
		occupant3.prev != occupant1 ||
		occupant3.next != occupant2 ||
		occupant2.prev != occupant3 ||
		occupant2.next != nil ||
		occupants.newest != occupant2 {
		t.Error("Broken")
	}
}

// ->[]->()->()->(.)-> +s(.)
func TestSetMUCOccupantsLRUSetReplaceLastWithSame(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// addition
	occupants.Set(3, occupant3)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant2 ||
		occupant2.prev != occupant1 ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != nil ||
		occupants.newest != occupant3 {
		t.Error("Broken")
	}
}

// ->[]->(.)-> +(.)
func TestSetMUCOccupantsLRUSetReplaceOnlyWithSame(t *testing.T) {
	// init
	occupants, occupant1 := testMUCOccupantsLRUChainOfOne()

	// addition
	occupants.Set(1, occupant1)

	// checks
	if occupants.oldest != occupant1 ||
		occupants.newest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != nil {
		t.Error("Broken")
	}
}

// ->[]->(X)->
func TestSetMUCOccupantsLRUDeleteOnly(t *testing.T) {
	// init
	occupants, occupant1 := testMUCOccupantsLRUChainOfOne()

	// deletion
	occupants.Delete(1)

	// checks
	if occupants.oldest != nil ||
		occupants.newest != nil ||
		occupant1.prev != nil ||
		occupant1.next != nil {
		t.Error("Broken")
	}
}

// ->[]->(X)->()->()->
func TestSetMUCOccupantsLRUDeleteFirst(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// deletion
	occupants.Delete(1)

	// checks
	if occupants.oldest != occupant2 ||
		occupant2.prev != nil ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != nil ||
		occupants.newest != occupant3 ||
		occupant1.prev != nil ||
		occupant1.next != nil {
		t.Error("Broken")
	}
}

// ->[]->()->(X)->()->
func TestSetMUCOccupantsLRUDeleteMiddle(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// deletion
	occupants.Delete(2)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant3 ||
		occupant3.prev != occupant1 ||
		occupant3.next != nil ||
		occupants.newest != occupant3 ||
		occupant2.prev != nil ||
		occupant2.next != nil {
		t.Error("Broken")
	}
}

// ->[]->()->()->(X)->
func TestSetMUCOccupantsLRUDeleteLast(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// deletion
	occupants.Delete(3)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant2 ||
		occupant2.prev != occupant1 ||
		occupant2.next != nil ||
		occupants.newest != occupant2 ||
		occupant3.prev != nil ||
		occupant3.next != nil {
		t.Error("Broken")
	}
}

// ->[]->(.)->
func TestSetMUCOccupantsLRUBumpOnly(t *testing.T) {
	// init
	occupants, occupant1 := testMUCOccupantsLRUChainOfOne()

	// bump
	occupants.Bump(occupant1)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != nil ||
		occupants.newest != occupant1 {
		t.Error("Broken")
	}
}

// ->[]->(.)->()->()->
func TestSetMUCOccupantsLRUBumpFirst(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// bump
	occupants.Bump(occupant1)

	// checks
	if occupants.oldest != occupant2 ||
		occupant2.prev != nil ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != occupant1 ||
		occupant1.prev != occupant3 ||
		occupant1.next != nil ||
		occupants.newest != occupant1 {
		t.Error("Broken")
	}
}

// ->[]->()->(.)->()->
func TestSetMUCOccupantsLRUBumpMiddle(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// bump
	occupants.Bump(occupant2)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant3 ||
		occupant3.prev != occupant1 ||
		occupant3.next != occupant2 ||
		occupant2.prev != occupant3 ||
		occupant2.next != nil ||
		occupants.newest != occupant2 {
		t.Error("Broken")
	}
}

// ->[]->()->()->(.)->
func TestSetMUCOccupantsLRUBumpLast(t *testing.T) {
	// init
	occupants, occupant1, occupant2, occupant3 := testMUCOccupantsLRUChainOfThree()

	// bump
	occupants.Bump(occupant3)

	// checks
	if occupants.oldest != occupant1 ||
		occupant1.prev != nil ||
		occupant1.next != occupant2 ||
		occupant2.prev != occupant1 ||
		occupant2.next != occupant3 ||
		occupant3.prev != occupant2 ||
		occupant3.next != nil ||
		occupants.newest != occupant3 {
		t.Error("Broken")
	}
}