package baishun

import (
	"context"
	"testing"
	"time"

	"chatapp3-golang/internal/model"
	"chatapp3-golang/internal/service/regionimgroup"

	"github.com/alicebob/miniredis/v2"
	"github.com/redis/go-redis/v9"
)

func TestHandleReportPublishesRegionHighWinAfterStartAndSettle(t *testing.T) {
	service, db := newTestBaishunService(t)
	mr := miniredis.RunT(t)
	redisClient := redis.NewClient(&redis.Options{Addr: mr.Addr()})
	t.Cleanup(func() { _ = redisClient.Close() })
	service.repo.Redis = redisClient
	broadcaster := &fakeBaishunRegionBroadcaster{}
	service.SetHighWinBroadcaster(broadcaster)

	expireAt := time.Now().Add(time.Hour)
	token := "ss-token-1001"
	if err := db.Create(&model.BaishunLaunchSession{
		ID:                1,
		SysOrigin:         "LIKEI",
		RoomID:            "9001",
		UserID:            1001,
		InternalGameID:    "bs_1146",
		VendorGameID:      1146,
		GameSessionID:     "session-1",
		SSToken:           &token,
		SSTokenExpireTime: &expireAt,
		Status:            baishunSessionActive,
		CreateTime:        time.Now(),
		UpdateTime:        time.Now(),
	}).Error; err != nil {
		t.Fatalf("seed session: %v", err)
	}
	if err := db.Create(&model.BaishunRoomState{
		ID:                  2,
		SysOrigin:           "LIKEI",
		RoomID:              "9001",
		HostUserID:          1001,
		CurrentGameID:       "bs_1146",
		CurrentVendorGameID: intPtr(1146),
		CurrentGameName:     "LordOfOlympus",
		CurrentGameCover:    "https://cdn.example.com/game.png",
		GameSessionID:       "session-1",
		State:               baishunRoomStatePlaying,
		CreateTime:          time.Now(),
		UpdateTime:          time.Now(),
	}).Error; err != nil {
		t.Fatalf("seed room state: %v", err)
	}

	startResp := service.HandleReport(context.Background(), BaishunReportRequest{
		ReportType: baishunReportTypeStart,
		UserID:     "1001",
		SSToken:    token,
		ReportMsg: map[string]any{
			"game_id":       1146,
			"room_id":       "9001",
			"game_round_id": "round-1",
			"players": []any{
				map[string]any{"user_id": "1001", "is_ai": 0, "bet": 100},
			},
		},
	}, `{"report_type":"game_start"}`)
	if startResp.Code != 0 {
		t.Fatalf("start response = %+v", startResp)
	}

	settleResp := service.HandleReport(context.Background(), BaishunReportRequest{
		ReportType: baishunReportTypeSettle,
		UserID:     "1001",
		SSToken:    token,
		ReportMsg: map[string]any{
			"game_id":       1146,
			"room_id":       "9001",
			"game_round_id": "round-1",
			"players": []any{
				map[string]any{"user_id": "1001", "is_ai": 0, "reward": 1000, "rank": 1, "score": 88},
			},
		},
	}, `{"report_type":"game_settle"}`)
	if settleResp.Code != 0 {
		t.Fatalf("settle response = %+v", settleResp)
	}

	if len(broadcaster.requests) != 1 {
		t.Fatalf("requests = %d, want 1", len(broadcaster.requests))
	}
	req := broadcaster.requests[0]
	if req.Type != "GAME_BAISHUN_WIN" {
		t.Fatalf("type = %q, want GAME_BAISHUN_WIN", req.Type)
	}
	if req.Data["userId"] != "1001" || req.Data["roomId"] != "9001" ||
		req.Data["multiple"] != int64(10) || req.Data["winAmount"] != int64(1000) ||
		req.Data["currencyDiff"] != int64(1000) ||
		req.Data["gameUrl"] != "https://cdn.example.com/game.png" {
		t.Fatalf("payload = %+v", req.Data)
	}
}

type fakeBaishunRegionBroadcaster struct {
	requests []regionimgroup.RegionBroadcastRequest
}

func (f *fakeBaishunRegionBroadcaster) SendRegionBroadcast(_ context.Context, req regionimgroup.RegionBroadcastRequest) (*regionimgroup.RegionBroadcastResponse, error) {
	f.requests = append(f.requests, req)
	return &regionimgroup.RegionBroadcastResponse{Type: req.Type}, nil
}