package conway_test

import (
	"testing"
)

import (
	. "github.com/meatballhat/box-o-sand/conway/go"
)

var TEST_SIMPLE_INITIAL_STATE = NewGameState(16, 16)

func init() {
	tsis := TEST_SIMPLE_INITIAL_STATE
	tsis.Set(0, 0, 1)
	tsis.Set(1, 0, 1)
	tsis.Set(0, 1, 1)
	tsis.Set(1, 1, 1)
	tsis.Set(2, 2, 1)
}

func TestNewGameOfLifeHasCorrectDimensions(t *testing.T) {
	game := NewGameOfLife(16, 16)
	if game.State.Height() != 16 || game.State.Width() != 16 {
		t.Fail()
	}
}

func TestNewGameOfLifeHasGameStateOfSameDimensions(t *testing.T) {
	game := NewGameOfLife(16, 16)

	if len(game.State.Rows) < 16 {
		t.Fail()
	}

	if len(game.State.Rows[0].Cols) < 16 {
		t.Fail()
	}
}

func TestGameStateCanImportState(t *testing.T) {
	game := NewGameOfLife(16, 16)
	err := game.State.Import(TEST_SIMPLE_INITIAL_STATE)
	if err != nil {
		t.Fail()
	}

	if value, err := game.State.Get(0, 0); err != nil || value != 1 {
		t.Fail()
	}

	if value, err := game.State.Get(1, 0); err != nil || value != 1 {
		t.Fail()
	}

	if value, err := game.State.Get(0, 1); err != nil || value != 1 {
		t.Fail()
	}

	if value, err := game.State.Get(1, 1); err != nil || value != 1 {
		t.Fail()
	}

	if value, err := game.State.Get(2, 2); err != nil || value != 1 {
		t.Fail()
	}
}

func TestLiveCellWithFewerThanTwoLiveNeighborsDies(t *testing.T) {
	game := NewGameOfLife(16, 16)
	err := game.State.Import(TEST_SIMPLE_INITIAL_STATE)
	if err != nil {
		t.Error(err)
		return
	}

	game.EvaluateGeneration()

	value, err := game.State.Get(2, 2)
	if err != nil {
		t.Error(err)
		return
	}

	if value != 0 {
		t.Errorf("%v != 0", value)
		return
	}
}

func TestLiveCellWithTwoOrThreeLiveNeighborsLivesOn(t *testing.T) {
	game := NewGameOfLife(16, 16)
	err := game.ImportState(TEST_SIMPLE_INITIAL_STATE)

	if err != nil {
		t.Error(err)
		return
	}

	game.EvaluateGeneration()

	value, err := game.State.Get(0, 0)
	if err != nil {
		t.Error(err)
		return
	}

	if value != 1 {
		t.Errorf("%v != 1", value)
		return
	}
}

func TestNewGameStatesAreAllDead(t *testing.T) {
	state := NewGameState(4, 4)
	for x := 0; x < 3; x++ {
		for y := 0; y < 3; y++ {
			if value, err := state.Get(x, y); err != nil || value != 0 {
				t.Fail()
			}
		}
	}
}

func TestGameStateCanGetCellValueByCoords(t *testing.T) {
	state := NewGameState(8, 8)
	if value, err := state.Get(2, 2); err != nil || value != 0 {
		t.Fail()
	}
}

func TestGameStateCanSetCellValueByCoords(t *testing.T) {
	state := NewGameState(8, 8)
	if err := state.Set(2, 5, 1); err != nil {
		t.Fail()
	}

	if value, err := state.Get(2, 5); err != nil || value != 1 {
		t.Fail()
	}
}

func TestGameStateCanEnlivenCellsByCoords(t *testing.T) {
	state := NewGameState(8, 8)
	if err := state.Enliven(0, 1); err != nil {
		t.Fail()
	}

	if value, err := state.Get(0, 1); err != nil || value != 1 {
		t.Fail()
	}
}

func TestGameStateCanDeadenCellsByCoords(t *testing.T) {
	state := NewGameState(8, 8)

	if err := state.Enliven(0, 1); err != nil {
		t.Fail()
	}

	if value, err := state.Get(0, 1); err != nil || value != 1 {
		t.Fail()
	}

	if err := state.Deaden(0, 1); err != nil {
		t.Fail()
	}

	if value, err := state.Get(0, 1); err != nil || value != 0 {
		t.Fail()
	}
}

func TestNewGenerationScoreCardIsAllZeros(t *testing.T) {
	gen := NewGenerationScoreCard(4, 4)

	for y := 0; y < gen.Height(); y++ {
		for x := 0; x < gen.Width(); x++ {
			if value, err := gen.Get(x, y); err != nil || value != 0 {
				t.Fail()
			}
		}
	}
}

func TestGenerationScoreCardCalculateResultsInCorrectNeighborCounts(t *testing.T) {
	genScore := NewGenerationScoreCard(16, 16)
	state := NewGameState(16, 16)

	err := state.Import(TEST_SIMPLE_INITIAL_STATE)
	if err != nil {
		t.Error(err)
		return
	}

	genScore.Calculate(state)
	value, err := genScore.Get(0, 0)
	if err != nil {
		t.Error(err)
		return
	} else if value != 3 {
		t.Errorf("[0, 0] value %v != 3", value)
		return
	}

	value, err = genScore.Get(2, 2)
	if err != nil {
		t.Error(err)
		return
	} else if value != 1 {
		t.Errorf("[2, 2] value %d != 1", value)
		return
	}
}