package backendclient_test

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"galaxy/gateway/internal/backendclient"
	"galaxy/gateway/internal/downstream"
	ordermodel "galaxy/model/order"
	reportmodel "galaxy/model/report"
	"galaxy/transcoder"

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

func TestExecuteUserGamesOrderForwardsAndDecodesResponse(t *testing.T) {
	t.Parallel()

	gameID := uuid.MustParse("11111111-2222-3333-4444-555555555555")
	applied := true
	source := &ordermodel.UserGamesOrder{
		GameID: gameID,
		Commands: []ordermodel.DecodableCommand{
			&ordermodel.CommandPlanetRename{
				CommandMeta: ordermodel.CommandMeta{
					CmdType: ordermodel.CommandTypePlanetRename,
					CmdID:   "00000000-0000-0000-0000-00000000aaaa",
				},
				Number: 7,
				Name:   "alpha",
			},
		},
	}

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodPost, r.Method)
		require.Equal(t, "/api/v1/user/games/"+gameID.String()+"/orders", r.URL.Path)
		require.Equal(t, "user-1", r.Header.Get(backendclient.HeaderUserID))
		writeJSON(t, w, http.StatusAccepted, map[string]any{
			"game_id":   gameID.String(),
			"updatedAt": int64(99),
			"cmd": []map[string]any{{
				"@type":      string(ordermodel.CommandTypePlanetRename),
				"cmdId":      "00000000-0000-0000-0000-00000000aaaa",
				"cmdApplied": applied,
				"planetNumber": 7,
				"name":         "alpha",
			}},
		})
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	payload, err := transcoder.UserGamesOrderToPayload(source)
	require.NoError(t, err)
	cmd := newAuthCommand(t, ordermodel.MessageTypeUserGamesOrder, payload)
	result, err := client.ExecuteGameCommand(context.Background(), cmd)
	require.NoError(t, err)
	assert.Equal(t, "ok", result.ResultCode)

	decoded, err := transcoder.PayloadToUserGamesOrderResponse(result.PayloadBytes)
	require.NoError(t, err)
	require.NotNil(t, decoded)
	assert.Equal(t, gameID, decoded.GameID)
	assert.Equal(t, int64(99), decoded.UpdatedAt)
	require.Len(t, decoded.Commands, 1)
	rename, ok := ordermodel.AsCommand[*ordermodel.CommandPlanetRename](decoded.Commands[0])
	require.True(t, ok)
	assert.Equal(t, "00000000-0000-0000-0000-00000000aaaa", rename.CmdID)
	require.NotNil(t, rename.CmdApplied)
	assert.True(t, *rename.CmdApplied)
}

func TestExecuteUserGamesOrderGetReturnsStored(t *testing.T) {
	t.Parallel()

	gameID := uuid.MustParse("22222222-3333-4444-5555-666666666666")
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodGet, r.Method)
		require.Equal(t, "/api/v1/user/games/"+gameID.String()+"/orders", r.URL.Path)
		require.Equal(t, "5", r.URL.Query().Get("turn"))
		writeJSON(t, w, http.StatusOK, map[string]any{
			"game_id":   gameID.String(),
			"updatedAt": int64(42),
			"cmd": []map[string]any{{
				"@type":        string(ordermodel.CommandTypePlanetRename),
				"cmdId":        "00000000-0000-0000-0000-00000000bbbb",
				"planetNumber": 9,
				"name":         "stored",
			}},
		})
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	payload, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: 5})
	require.NoError(t, err)
	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, ordermodel.MessageTypeUserGamesOrderGet, payload))
	require.NoError(t, err)
	assert.Equal(t, "ok", result.ResultCode)

	stored, found, err := transcoder.PayloadToUserGamesOrderGetResponse(result.PayloadBytes)
	require.NoError(t, err)
	require.True(t, found)
	require.NotNil(t, stored)
	assert.Equal(t, gameID, stored.GameID)
	assert.Equal(t, int64(42), stored.UpdatedAt)
	require.Len(t, stored.Commands, 1)
	rename, ok := ordermodel.AsCommand[*ordermodel.CommandPlanetRename](stored.Commands[0])
	require.True(t, ok)
	assert.Equal(t, 9, rename.Number)
	assert.Equal(t, "stored", rename.Name)
}

func TestExecuteUserGamesOrderGetMapsNoContent(t *testing.T) {
	t.Parallel()

	gameID := uuid.MustParse("33333333-4444-5555-6666-777777777777")
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, "11", r.URL.Query().Get("turn"))
		w.WriteHeader(http.StatusNoContent)
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	payload, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: 11})
	require.NoError(t, err)
	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, ordermodel.MessageTypeUserGamesOrderGet, payload))
	require.NoError(t, err)
	assert.Equal(t, "ok", result.ResultCode)

	stored, found, err := transcoder.PayloadToUserGamesOrderGetResponse(result.PayloadBytes)
	require.NoError(t, err)
	assert.False(t, found)
	assert.Nil(t, stored)
}

func TestExecuteUserGamesOrderGetRejectsNegativeTurn(t *testing.T) {
	t.Parallel()

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t.Fatal("server must not be hit on negative turn")
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	gameID := uuid.MustParse("44444444-5555-6666-7777-888888888888")
	// PayloadToUserGamesOrderGet rejects negative turns at decode
	// time; force the negative case by hand-crafting a payload via
	// the encoder set to 0 then mutating the buffer is fragile, so
	// instead exercise the encoder's own non-negative check.
	_, err := transcoder.UserGamesOrderGetToPayload(&ordermodel.UserGamesOrderGet{GameID: gameID, Turn: -1})
	require.Error(t, err)

	// And verify the dispatch path also surfaces the encoder error
	// when wrapping a manually-signed envelope: the request payload
	// is empty so the decoder reports "data is empty", which the
	// dispatcher wraps with the message-type prefix.
	_, err = client.ExecuteGameCommand(context.Background(), downstream.AuthenticatedCommand{
		MessageType:  ordermodel.MessageTypeUserGamesOrderGet,
		PayloadBytes: nil,
		UserID:       "user-1",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "user.games.order.get")
}

func TestExecuteUserGamesBattleForwardsAndDecodesResponse(t *testing.T) {
	t.Parallel()

	gameID := uuid.MustParse("66666666-7777-8888-9999-aaaaaaaaaaaa")
	battleID := uuid.MustParse("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		require.Equal(t, http.MethodGet, r.Method)
		require.Equal(t,
			"/api/v1/user/games/"+gameID.String()+"/battles/7/"+battleID.String(),
			r.URL.Path,
		)
		require.Equal(t, "user-1", r.Header.Get(backendclient.HeaderUserID))
		raceID := uuid.MustParse("11111111-2222-3333-4444-555555555555")
		writeJSON(t, w, http.StatusOK, map[string]any{
			"id":         battleID.String(),
			"planet":     uint(42),
			"planetName": "Tau Ceti II",
			"races":      map[string]string{"1": raceID.String()},
			"ships":      map[string]map[string]any{},
			"protocol":   []any{},
		})
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
		GameID:   gameID,
		Turn:     7,
		BattleID: battleID,
	})
	require.NoError(t, err)
	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
	require.NoError(t, err)
	assert.Equal(t, "ok", result.ResultCode)

	decoded, err := transcoder.PayloadToBattleReport(result.PayloadBytes)
	require.NoError(t, err)
	require.NotNil(t, decoded)
	assert.Equal(t, battleID, decoded.ID)
	assert.Equal(t, uint(42), decoded.Planet)
	assert.Equal(t, "Tau Ceti II", decoded.PlanetName)
}

func TestExecuteUserGamesBattleMapsNotFound(t *testing.T) {
	t.Parallel()

	gameID := uuid.MustParse("77777777-8888-9999-aaaa-bbbbbbbbbbbb")
	battleID := uuid.MustParse("99999999-aaaa-bbbb-cccc-dddddddddddd")

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		writeJSON(t, w, http.StatusNotFound, map[string]any{
			"error": map[string]any{
				"code":    "not_found",
				"message": "battle not found",
			},
		})
	}))
	t.Cleanup(server.Close)

	client := newRESTClient(t, server)
	payload, err := transcoder.GameBattleRequestToPayload(&reportmodel.GameBattleRequest{
		GameID:   gameID,
		Turn:     2,
		BattleID: battleID,
	})
	require.NoError(t, err)
	result, err := client.ExecuteGameCommand(context.Background(), newAuthCommand(t, reportmodel.MessageTypeUserGamesBattle, payload))
	require.NoError(t, err)
	assert.Equal(t, "not_found", result.ResultCode)
}

// writeJSON copy below mirrors the helper used by other test files
// in this package; keeping it adjacent to its callers avoids
// reaching across files in a fresh test.
//
// TODO(phase14): collapse the two writeJSON copies once the package
// gains a shared `helpers_test.go`. Phase 14 keeps the duplicate to
// avoid touching unrelated tests.
var _ = json.Marshal // keep encoding/json import if writeJSON is hoisted

func init() {
	// Sanity-check that the package-level writeJSON helper is
	// declared by another _test.go file we depend on; if a future
	// refactor removes it, this test file will not compile.
	_ = strings.TrimSpace
}