package repo_test

import (
	"path/filepath"
	"testing"

	"galaxy/model/order"

	"galaxy/server/internal/repo"
	"galaxy/server/internal/repo/fs"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
)

func TestSaveOrder(t *testing.T) {
	root := t.ArtifactDir()
	s, err := fs.NewFileStorage(root)
	assert.NoError(t, err)
	id := uuid.New()
	o := &order.Order{
		Commands: []order.DecodableCommand{
			&order.CommandRaceVote{
				CommandMeta: order.CommandMeta{
					CmdType: order.CommandTypeRaceVote,
					CmdID:   uuid.New().String(),
				},
				Acceptor: "Race_acc",
			},
			&order.CommandShipClassCreate{
				CommandMeta: order.CommandMeta{
					CmdType: order.CommandTypeShipClassCreate,
					CmdID:   uuid.New().String(),
				},
				Name:     "Fighter",
				Drive:    20.5,
				Armament: 5,
				Weapons:  20,
				Shields:  15.5,
				Cargo:    0,
			},
			&order.CommandShipGroupMerge{
				CommandMeta: order.CommandMeta{
					CmdType: order.CommandTypeShipGroupMerge,
					CmdID:   uuid.New().String(),
				},
			},
			&order.CommandShipClassCreate{
				CommandMeta: order.CommandMeta{
					CmdType: order.CommandTypeShipClassCreate,
					CmdID:   uuid.New().String(),
				},
				Name:     "Freighter",
				Drive:    30.33,
				Armament: 1,
				Weapons:  1,
				Shields:  10.1,
				Cargo:    0,
			},
			&order.CommandRaceQuit{
				CommandMeta: order.CommandMeta{
					CmdType: order.CommandTypeRaceQuit,
					CmdID:   uuid.New().String(),
				},
			},
		},
	}
	var turn uint = 2

	for i := range o.Commands {
		if v, ok := order.AsCommand[*order.CommandRaceVote](o.Commands[i]); ok {
			m := &v.CommandMeta
			m.Result(0)
		} else if v, ok := order.AsCommand[*order.CommandRaceQuit](o.Commands[i]); ok {
			v.Result(10)
		} else if v, ok := order.AsCommand[*order.CommandShipClassCreate](o.Commands[i]); ok {
			m := &v.CommandMeta
			m.Result(33)
		} else if v, ok := order.AsCommand[*order.CommandShipGroupMerge](o.Commands[i]); ok {
			v.Result(0)
		}
	}

	assert.NoError(t, repo.SaveOrder_T(s, turn, id, o))
	assert.FileExists(t, filepath.Join(root, repo.OrderDir(turn, id)))

	LoadOrderTest(t, s, root, turn, id, o)
}

func LoadOrderTest(t *testing.T, s repo.Storage, root string, turn uint, id uuid.UUID, expected *order.Order) {
	o, ok, err := repo.LoadOrder_T(s, turn, id)
	assert.NoError(t, err)
	assert.True(t, ok)
	assert.Len(t, o.Commands, 5)
	assert.ElementsMatch(t, expected.Commands, o.Commands)

	CommandResultTest(t, o)
}

func CommandResultTest(t *testing.T, o *order.Order) {
	assert.NotEmpty(t, o.Commands)
	for i := range o.Commands {
		if v, ok := order.AsCommand[*order.CommandRaceVote](o.Commands[i]); ok {
			assert.NotNil(t, v.CmdApplied)
			assert.True(t, *v.CmdApplied)
			assert.Equal(t, 0, *v.CmdErrCode)
		} else if v, ok := order.AsCommand[*order.CommandRaceQuit](o.Commands[i]); ok {
			assert.NotNil(t, v.CmdApplied)
			assert.False(t, *v.CmdApplied)
			assert.Equal(t, 10, *v.CmdErrCode)
		} else if v, ok := order.AsCommand[*order.CommandShipClassCreate](o.Commands[i]); ok {
			assert.NotNil(t, v.CmdApplied)
			assert.False(t, *v.CmdApplied)
			assert.Equal(t, 33, *v.CmdErrCode)
		} else if v, ok := order.AsCommand[*order.CommandShipGroupMerge](o.Commands[i]); ok {
			assert.NotNil(t, v.CmdApplied)
			assert.True(t, *v.CmdApplied)
			assert.Equal(t, 0, *v.CmdErrCode)
		}
	}
}