package router_test

import (
	"encoding/json"
	"net/http"
	"testing"

	"galaxy/model/order"
	"galaxy/model/report"

	"galaxy/game/internal/controller"
	"galaxy/game/internal/model/game"
	"galaxy/game/internal/router"
	"galaxy/game/internal/router/handler"

	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
)

var (
	commandNoErrorsStatus = http.StatusAccepted
	commandDefaultActor   = "Gorlum"
	apiCommandMethod      = "PUT"
	apiOrderPath          = "/api/v1/order"
	validId1              = id()
	validId2              = id()
	invalidId             = "fd091c69-5976-4775-b2f9-7ba77735afb"
)

func id() string {
	return uuid.New().String()
}

type fakeEngine struct {
	CommandsExecuted int

	// ValidateOrderResult, when non-nil, is returned from ValidateOrder.
	// When nil, ValidateOrder synthesises an order from the received args
	// so the response body is non-empty for status assertions.
	ValidateOrderResult *order.UserGamesOrder
	ValidateOrderErr    error

	// FetchOrder controls and observes calls to FetchOrder.
	FetchOrderActor  string
	FetchOrderTurn   uint
	FetchOrderResult *order.UserGamesOrder
	FetchOrderOK     bool
	FetchOrderErr    error

	// FetchBattle controls and observes calls to FetchBattle.
	FetchBattleTurn   uint
	FetchBattleID     uuid.UUID
	FetchBattleResult *report.BattleReport
	FetchBattleOK     bool
	FetchBattleErr    error
}

func (e *fakeEngine) ValidateOrder(actor string, cmd ...order.DecodableCommand) (*order.UserGamesOrder, error) {
	e.CommandsExecuted = len(cmd)
	if e.ValidateOrderErr != nil {
		return nil, e.ValidateOrderErr
	}
	if e.ValidateOrderResult != nil {
		return e.ValidateOrderResult, nil
	}
	return &order.UserGamesOrder{
		GameID:    uuid.New(),
		UpdatedAt: 1,
		Commands:  append([]order.DecodableCommand(nil), cmd...),
	}, nil
}

func (e *fakeEngine) FetchOrder(actor string, turn uint) (*order.UserGamesOrder, bool, error) {
	e.FetchOrderActor = actor
	e.FetchOrderTurn = turn
	return e.FetchOrderResult, e.FetchOrderOK, e.FetchOrderErr
}

func (e *fakeEngine) FetchBattle(turn uint, ID uuid.UUID) (*report.BattleReport, bool, error) {
	e.FetchBattleTurn = turn
	e.FetchBattleID = ID
	return e.FetchBattleResult, e.FetchBattleOK, e.FetchBattleErr
}

func (e *fakeEngine) GenerateGame(gameID uuid.UUID, races []string) (game.State, error) {
	return game.State{ID: gameID}, nil
}

func (e *fakeEngine) GenerateTurn() (game.State, error) {
	return game.State{}, nil
}

func (e *fakeEngine) BanishRace(raceName string) error {
	return nil
}

func (e *fakeEngine) GameState() (game.State, error) {
	return game.State{}, nil
}

func (e *fakeEngine) LoadReport(actor string, turn uint) (*report.Report, error) {
	return &report.Report{}, nil
}

func setupRouter() *gin.Engine {
	return setupRouterEngine(newFakeEngine())
}

func setupRouterEngine(e handler.Engine) *gin.Engine {
	return router.SetupRouter(e)
}

func newFakeEngine() handler.Engine {
	return &fakeEngine{}
}

// newService builds a real controller.Service backed by a storage directory,
// for handler tests that exercise the engine end to end rather than the fake.
func newService(t *testing.T, root string) *controller.Service {
	t.Helper()
	svc, err := controller.NewService(root)
	if err != nil {
		t.Fatalf("new service: %v", err)
	}
	return svc
}

func encodeCommand(cmd any) json.RawMessage {
	v, err := json.Marshal(cmd)
	if err != nil {
		panic(err)
	}
	return v
}