package d2ds1

import (
	"testing"

	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2path"
)

func exampleDS1() *DS1 {
	return &DS1{
		files: []string{"a.dt1", "b.dt1"},
		objects: []Object{
			{0, 0, 0, 0, 0, nil},
			{0, 1, 0, 0, 0, []d2path.Path{{}}},
			{0, 2, 0, 0, 0, nil},
			{0, 3, 0, 0, 0, nil},
		},
		tiles: [][]Tile{ // 2x2
			{
				Tile{
					[]Floor{{}},
					[]Wall{{}},
					[]Shadow{{}},
					[]Substitution{{}},
				},
				Tile{
					[]Floor{{}},
					[]Wall{{}},
					[]Shadow{{}},
					[]Substitution{{}},
				},
			},
			{
				Tile{
					[]Floor{{}},
					[]Wall{{}},
					[]Shadow{{}},
					[]Substitution{{}},
				},
				Tile{
					[]Floor{{}},
					[]Wall{{}},
					[]Shadow{{}},
					[]Substitution{{}},
				},
			},
		},
		substitutionGroups:         nil,
		version:                    17,
		width:                      2,
		height:                     2,
		act:                        1,
		substitutionType:           0,
		numberOfWallLayers:         1,
		numberOfFloorLayers:        1,
		numberOfShadowLayers:       1,
		numberOfSubstitutionLayers: 1,
	}
}

// checks, if DS1 structure could be marshaled and unmarshaled
func testIfRestorable(ds1 *DS1, test func(ds1 *DS1)) error {
	test(ds1)

	var err error

	data := ds1.Marshal()

	newDS1, err := LoadDS1(data)
	if err != nil {
		return err
	}

	test(newDS1)

	return nil
}

func TestDS1_Marshal(t *testing.T) {
	a := exampleDS1()

	bytes := a.Marshal()

	b, err := LoadDS1(bytes)
	if err != nil {
		t.Error("could not load new ds1 from marshaled ds1 data")
		return
	}

	if b.width != a.width {
		t.Error("new ds1 does not match original")
	}

	if len(b.tiles) != len(a.tiles) {
		t.Error("new ds1 does not batch original")
	}
}

func TestDS1_Files(t *testing.T) {
	ds1 := exampleDS1()

	files := ds1.Files()

	for idx := range files {
		if ds1.files[idx] != files[idx] {
			t.Error("unexpected files from ds1")
		}
	}
}

func TestDS1_AddFile(t *testing.T) {
	ds1 := exampleDS1()

	numBefore := len(ds1.files)

	ds1.AddFile("other.ds1")

	numAfter := len(ds1.files)

	test := func(ds1 *DS1) {
		if (numBefore + 1) != numAfter {
			t.Error("unexpected number of files in ds1")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_RemoveFile(t *testing.T) {
	ds1 := exampleDS1()

	test := func(ds1 *DS1) {
		numBefore := len(ds1.files)

		err := ds1.RemoveFile("nonexistant file")
		if err == nil {
			t.Fatal("file 'nonexistant file' doesn't exist but ds1.RemoveFile doesn't return error")
		}

		if len(ds1.files) != numBefore {
			t.Error("file removed when it should not have been")
		}

		filename := "c.ds1"

		ds1.AddFile(filename)

		if len(ds1.files) == numBefore {
			t.Error("file not added when it should have been")
		}

		err = ds1.RemoveFile(filename)
		if err != nil {
			t.Error(err)
		}

		if len(ds1.files) != numBefore {
			t.Error("file not removed when it should have been")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Objects(t *testing.T) {
	ds1 := exampleDS1()

	objects := ds1.Objects()

	for idx := range ds1.objects {
		if !ds1.objects[idx].Equals(&objects[idx]) {
			t.Error("unexpected object")
		}
	}
}

func TestDS1_AddObject(t *testing.T) {
	ds1 := exampleDS1()

	numBefore := len(ds1.objects)

	ds1.AddObject(Object{})

	numAfter := len(ds1.objects)

	test := func(ds1 *DS1) {
		if (numBefore + 1) != numAfter {
			t.Error("unexpected number of objects in ds1")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_RemoveObject(t *testing.T) {
	ds1 := exampleDS1()

	nice := 69420

	obj := Object{
		ID: nice,
	}

	ds1.AddObject(obj)

	numBefore := len(ds1.objects)

	ds1.RemoveObject(obj)

	test := func(ds1 *DS1) {
		if len(ds1.objects) == numBefore {
			t.Error("did not remove object when expected")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Tiles(t *testing.T) {
	ds1 := exampleDS1()

	tiles := ds1.Tiles()

	for y := range tiles {
		for x := range tiles[y] {
			if len(ds1.tiles[y][x].Floors) != len(tiles[y][x].Floors) {
				t.Fatal("number of tile's floors returned by ds1.Tiles() isn't same as real number")
			}

			if ds1.tiles[y][x].Walls[0] != tiles[y][x].Walls[0] {
				t.Fatal("wall record returned by ds1.Tiles isn't equal to real")
			}
		}
	}
}

func TestDS1_SetTiles(t *testing.T) {
	ds1 := exampleDS1()

	exampleTile1 := Tile{
		Floors: []floorShadow{
			{8, 7, 2, 3, 4, 55, 33, true, 999},
		},
		Walls: []Wall{
			{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
			{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
		},
		Shadows: []floorShadow{
			{2, 4, 5, 33, 6, 7, 0, false, 1024},
		},
	}

	exampleTile2 := Tile{
		Floors: []floorShadow{
			{9, 9, 2, 3, 4, 55, 33, true, 999},
			{9, 8, 2, 3, 102, 55, 33, true, 999},
		},
		Walls: []Wall{
			{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
		},
		Shadows: []floorShadow{
			{2, 4, 5, 33, 6, 7, 0, false, 1024},
		},
	}

	tiles := [][]Tile{{exampleTile1, exampleTile2}, {exampleTile2, exampleTile1}}

	ds1.SetTiles(tiles)

	test := func(ds1 *DS1) {
		if ds1.tiles[0][0].Floors[0].Prop1 != exampleTile1.Floors[0].Prop1 {
			t.Fatal("1,unexpected tile was set")
		}

		if len(ds1.tiles[0][0].Walls) != len(exampleTile1.Walls) {
			t.Fatal("2,unexpected tile was set")
		}

		if ds1.tiles[0][1].Walls[0].Style != exampleTile2.Walls[0].Style {
			t.Fatal("3,unexpected tile was set")
		}

		if len(ds1.tiles[0][0].Walls) != len(exampleTile1.Walls) {
			t.Fatal("4,unexpected tile was set")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Tile(t *testing.T) {
	ds1 := exampleDS1()

	x, y := 1, 0

	if ds1.tiles[y][x].Floors[0] != ds1.Tile(x, y).Floors[0] {
		t.Fatal("ds1.Tile returned invalid value")
	}
}

func TestDS1_SetTile(t *testing.T) {
	ds1 := exampleDS1()

	exampleTile := Tile{
		Floors: []floorShadow{
			{5, 8, 9, 4, 3, 0, 0, true, 1024},
		},
		Walls: []Wall{
			{2, 0, 4, 5, 3, 2, 3, 0, 33, 99},
			{5, 8, 9, 4, 3, 0, 0, 124, 221, 12},
		},
		Shadows: []floorShadow{
			{2, 44, 99, 2, 4, 3, 2, true, 933},
		},
	}

	ds1.SetTile(0, 0, &exampleTile)

	test := func(ds1 *DS1) {
		if ds1.tiles[0][0].Floors[0].Prop1 != exampleTile.Floors[0].Prop1 {
			t.Fatal("unexpected tile was set")
		}

		if ds1.tiles[0][0].Walls[0].Zero != exampleTile.Walls[0].Zero {
			t.Fatal("unexpected tile was set")
		}

		if len(ds1.tiles[0][0].Walls) != len(exampleTile.Walls) {
			t.Fatal("unexpected tile was set")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Version(t *testing.T) {
	ds1 := exampleDS1()

	version := ds1.version

	if version != int32(ds1.Version()) {
		t.Fatal("version returned by ds1.Version() and real aren't equal")
	}
}

func TestDS1_SetVersion(t *testing.T) {
	ds1 := exampleDS1()

	newVersion := 8

	ds1.SetVersion(newVersion)

	test := func(ds1 *DS1) {
		if newVersion != int(ds1.version) {
			t.Fatal("ds1.SetVersion set version incorrectly")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Width(t *testing.T) {
	ds1 := exampleDS1()

	if int(ds1.width) != ds1.Width() {
		t.Error("unexpected width")
	}
}

func TestDS1_SetWidth(t *testing.T) {
	ds1 := exampleDS1()

	var newWidth int32 = 4

	ds1.SetWidth(int(newWidth))

	test := func(ds1 *DS1) {
		if newWidth != ds1.width {
			t.Fatal("unexpected width after set")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Height(t *testing.T) {
	ds1 := exampleDS1()

	if int(ds1.height) != ds1.Height() {
		t.Error("unexpected height")
	}
}

func TestDS1_SetHeight(t *testing.T) {
	ds1 := exampleDS1()

	var newHeight int32 = 5

	ds1.SetHeight(int(newHeight))

	test := func(ds1 *DS1) {
		if newHeight != ds1.height {
			t.Fatal("unexpected heigth after set")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_Act(t *testing.T) {
	ds1 := exampleDS1()

	if ds1.Act() != int(ds1.act) {
		t.Error("unexpected value in example ds1")
	}
}

func TestDS1_SetAct(t *testing.T) {
	ds1 := exampleDS1()

	ds1.SetAct(-1)

	if ds1.Act() < 0 {
		t.Error("act cannot be less than 0")
	}

	nice := 5

	ds1.SetAct(nice)

	test := func(ds1 *DS1) {
		if int(ds1.act) != nice {
			t.Error("unexpected value for act")
		}
	}

	if err := testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_SubstitutionType(t *testing.T) {
	ds1 := exampleDS1()

	st := ds1.substitutionType

	if int(st) != ds1.SubstitutionType() {
		t.Fatal("unexpected substitution type returned")
	}
}

func TestDS1_SetSubstitutionType(t *testing.T) {
	ds1 := exampleDS1()

	newST := 5

	ds1.SetSubstitutionType(newST)

	if ds1.substitutionType != int32(newST) {
		t.Fatal("unexpected substitutionType was set")
	}
}

func TestDS1_NumberOfWalls(t *testing.T) {
	ds1 := exampleDS1()

	if ds1.NumberOfWallLayers() != int(ds1.numberOfWallLayers) {
		t.Error("unexpected number of wall layers")
	}
}

func TestDS1_SetNumberOfWalls(t *testing.T) {
	var err error

	ds1 := exampleDS1()

	newNumber := int32(4)

	err = ds1.SetNumberOfWallLayers(newNumber)
	if err != nil {
		t.Errorf("error setting number of walls: %v", err)
	}

	test := func(ds1 *DS1) {
		if len(ds1.tiles[0][0].Walls) != int(newNumber) {
			t.Fatal("unexpected walls length set")
		}

		if ds1.NumberOfWallLayers() != int(newNumber) {
			t.Fatal("unexpected walls length set")
		}
	}

	if err = testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}

	newNumber = 1

	err = ds1.SetNumberOfWallLayers(newNumber)
	if err != nil {
		t.Errorf("error setting number of walls: %v", err)
	}

	test = func(ds1 *DS1) {
		if len(ds1.tiles[0][0].Walls) != int(newNumber) {
			t.Fatal("unexpected walls length set")
		}

		if ds1.NumberOfWallLayers() != int(newNumber) {
			t.Fatal("unexpected walls length set")
		}
	}

	if err = testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_NumberOfFloors(t *testing.T) {
	ds1 := exampleDS1()

	if ds1.NumberOfFloorLayers() != int(ds1.numberOfFloorLayers) {
		t.Error("unexpected number of floor layers")
	}
}

func TestDS1_SetNumberOfFloors(t *testing.T) {
	var err error

	ds1 := exampleDS1()

	newNumber := int32(2)

	err = ds1.SetNumberOfFloorLayers(newNumber)
	if err != nil {
		t.Errorf("error setting number of floors: %v", err)
	}

	test := func(ds1 *DS1) {
		if len(ds1.tiles[0][0].Floors) != int(newNumber) {
			t.Fatal("unexpected floors length set")
		}

		if ds1.numberOfFloorLayers != newNumber {
			t.Fatal("unexpected floors length set")
		}
	}

	if err = testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}

	newNumber = 1

	err = ds1.SetNumberOfFloorLayers(newNumber)
	if err != nil {
		t.Errorf("error setting number of floors: %v", err)
	}

	test = func(ds1 *DS1) {
		if len(ds1.tiles[0][0].Floors) != int(newNumber) {
			t.Fatal("unexpected floors length set")
		}

		if ds1.numberOfFloorLayers != newNumber {
			t.Fatal("unexpected floors length set")
		}
	}

	if err = testIfRestorable(ds1, test); err != nil {
		t.Errorf("unable to restore: %v", err)
	}
}

func TestDS1_NumberOfShadowLayers(t *testing.T) {
	ds1 := exampleDS1()

	if ds1.NumberOfShadowLayers() != int(ds1.numberOfShadowLayers) {
		t.Error("unexpected number of shadow layers")
	}
}

func TestDS1_NumberOfSubstitutionLayers(t *testing.T) {
	ds1 := exampleDS1()

	if ds1.NumberOfSubstitutionLayers() != int(ds1.numberOfSubstitutionLayers) {
		t.Error("unexpected number of substitution layers")
	}
}

func TestDS1_SubstitutionGroups(t *testing.T) {
	ds1 := exampleDS1()

	sg := ds1.SubstitutionGroups()

	for i := 0; i < len(ds1.substitutionGroups); i++ {
		if sg[i] != ds1.substitutionGroups[i] {
			t.Fatal("unexpected substitution group returned")
		}
	}
}

func TestDS1_SetSubstitutionGroups(t *testing.T) {
	ds1 := exampleDS1()

	newGroup := []SubstitutionGroup{
		{
			TileX:         20,
			TileY:         12,
			WidthInTiles:  212,
			HeightInTiles: 334,
			Unknown:       1024,
		},
	}

	ds1.SetSubstitutionGroups(newGroup)

	if ds1.substitutionGroups[0] != newGroup[0] {
		t.Fatal("unexpected substitution group added")
	}
}

func TestDS1_GetStreamLayerTypes(t *testing.T) {
	ds1 := exampleDS1()

	lst := []d2enum.LayerStreamType{
		d2enum.LayerStreamWall1,
		d2enum.LayerStreamOrientation1,
		d2enum.LayerStreamFloor1,
		d2enum.LayerStreamShadow,
		d2enum.LayerStreamSubstitute,
	}

	layerStreamTypes := ds1.GetStreamLayerTypes()

	if len(lst) != len(layerStreamTypes) {
		t.Fatal("unexpected length")
	}

	for i := range lst {
		if lst[i] != layerStreamTypes[i] {
			t.Fatal("Unexpected type was set")
		}
	}
}