package d2ds1

import (
	"fmt"

	"testing"

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

func exampleDS1() *DS1 {
	return &DS1{
		files: []string{"a.dt1", "b.dt1"},
		objects: []Object{
			{0, 0, 0, 0, 0, nil},
			{0, 1, 0, 0, 0, nil},
			{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,
		layerStreamTypes: []d2enum.LayerStreamType{
			d2enum.LayerStreamWall1,
			d2enum.LayerStreamOrientation1,
			d2enum.LayerStreamFloor1,
			d2enum.LayerStreamShadow,
		},
		npcIndexes: []int{},
	}
}

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

	data := ds1.Marshal()
	_, err = LoadDS1(data)

	return err
}

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")
	}
}

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)

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

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

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

	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); 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)

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

	if err := testIfRestorable(ds1); 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)

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

	if err := testIfRestorable(ds1); 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{
			{0, 0, 2, 3, 4, 55, 33, true, 999},
		},
		Shadows: []FloorShadow{
			{2, 4, 5, 33, 6, 7, 0, false, 1024},
		},
	}

	exampleTile2 := Tile{
		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}}

	ds1.SetTiles(tiles)

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

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

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

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

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, 4, 2, true, 1024},
			{8, 22, 7, 9, 6, 3, 0, false, 1024},
		},
		Walls: []Wall{
			{2, 3, 4, 5, 3, 2, 3, 0, 33, 99},
		},
		Shadows: []FloorShadow{
			{2, 44, 99, 2, 4, 3, 2, true, 933},
		},
	}

	ds1.SetTile(0, 0, &exampleTile)

	if ds1.tiles[0][0].Floors[0] != exampleTile.Floors[0] {
		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); 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)

	if newVersion != int(ds1.version) {
		t.Fatal("ds1.SetVersion set version incorrectly")
	}

	if err := testIfRestorable(ds1); 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))

	if newWidth != ds1.width {
		t.Fatal("unexpected width after set")
	}

	if err := testIfRestorable(ds1); 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))

	if newHeight != ds1.height {
		fmt.Println(newHeight, ds1.height)
		t.Fatal("unexpected heigth after set")
	}

	if err := testIfRestorable(ds1); 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 := 69420

	ds1.SetAct(nice)

	if int(ds1.act) != nice {
		t.Error("unexpected value for act")
	}

	if err := testIfRestorable(ds1); 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_NumberOfFloors(t *testing.T) {
	ds1 := exampleDS1()

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

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")
	}
}