package api

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

	"github.com/cosmic-clash/cosmic-clash/server/domain"
)

func TestAuthenticatedQueueAPIUsesServerCandidateAndRevisionedMutations(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, err := sessions.Issue("player-1", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	queue := domain.NewQueue()
	service := &Service{Sessions: sessions, Queue: queue, Now: func() time.Time { return now }, Candidate: func(playerID, ticketID string) (domain.Candidate, error) {
		return domain.Candidate{PlayerID: playerID, TicketID: ticketID, EnqueuedAt: now, PredictedRTT: map[string]float64{"EU": 20}}, nil
	}}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	request := func(method, path, body string, headers map[string]string) *http.Response {
		req, _ := http.NewRequest(method, server.URL+path, strings.NewReader(body))
		for key, value := range headers {
			req.Header.Set(key, value)
		}
		response, requestErr := http.DefaultClient.Do(req)
		if requestErr != nil {
			t.Fatal(requestErr)
		}
		return response
	}
	headers := map[string]string{"Authorization": "Bearer " + session.SessionID + ":" + token, "Idempotency-Key": "create-key-123456"}
	response := request(http.MethodPost, "/v1/queue", `{"ticket_id":"ticket-1","playlist":"casual","client_build":"build-1","protocol_version":1}`, headers)
	if response.StatusCode != http.StatusCreated {
		t.Fatalf("create status = %d", response.StatusCode)
	}
	var created queueResponse
	if err := json.NewDecoder(response.Body).Decode(&created); err != nil {
		t.Fatal(err)
	}
	_ = response.Body.Close()
	if created.PlayerID != "player-1" || created.State != "QUEUED" || created.Revision != 0 {
		t.Fatalf("created = %+v", created)
	}
	response = request(http.MethodPost, "/v1/queue/ticket-1/heartbeat", `{}`, map[string]string{"Authorization": headers["Authorization"], "Idempotency-Key": "heartbeat-key-123456", "If-Match-Revision": "0"})
	if response.StatusCode != http.StatusOK {
		t.Fatalf("heartbeat status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	response = request(http.MethodPost, "/v1/queue/ticket-1/cancel", `{}`, map[string]string{"Authorization": headers["Authorization"], "Idempotency-Key": "cancel-key-123456", "If-Match-Revision": "0"})
	if response.StatusCode != http.StatusConflict {
		t.Fatalf("stale cancel status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
}

func TestQueueAPIRejectsUnauthenticatedUnknownAndOversizedInput(t *testing.T) {
	service := &Service{Sessions: domain.NewSessionStore(), Queue: domain.NewQueue(), Candidate: func(string, string) (domain.Candidate, error) { return domain.Candidate{}, nil }}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	request, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":"ticket-1","playlist":"casual","client_build":"build-1","protocol_version":1,"player_id":"attacker"}`))
	request.Header.Set("Idempotency-Key", "create-key-123456")
	response, err := http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusUnauthorized {
		t.Fatalf("unauthenticated status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	sessionStore := domain.NewSessionStore()
	session, token, _ := sessionStore.Issue("player-1", time.Hour, time.Now())
	service.Sessions = sessionStore
	request, _ = http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":"ticket-1","playlist":"casual","client_build":"build-1","protocol_version":1,"unknown":true}`))
	request.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	request.Header.Set("Idempotency-Key", "create-key-123456")
	response, err = http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusBadRequest {
		t.Fatalf("unknown field status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	request, _ = http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":`))
	request.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	request.Header.Set("Idempotency-Key", "create-key-654321")
	response, err = http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusBadRequest {
		t.Fatalf("malformed body status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	request, _ = http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":"ticket-1","playlist":"casual","client_build":"build-1","protocol_version":1}{"ticket_id":"ticket-2"}`))
	request.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	request.Header.Set("Idempotency-Key", "create-key-789012")
	response, err = http.DefaultClient.Do(request)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusBadRequest {
		t.Fatalf("trailing JSON status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
}

func TestQueueCreateRequiresCompatibilityMetadataAndPassesItToProvider(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, err := sessions.Issue("player-1", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	var got domain.QueueSpec
	service := &Service{
		Sessions: sessions,
		Queue:    domain.NewQueue(),
		Now:      func() time.Time { return now },
		CandidateV2: func(_ string, ticketID string, spec domain.QueueSpec) (domain.Candidate, error) {
			got = spec
			return domain.Candidate{PlayerID: "player-1", TicketID: ticketID, Playlist: spec.Playlist, ClientBuild: spec.ClientBuild, ProtocolVersion: spec.ProtocolVersion, EnqueuedAt: now}, nil
		},
	}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	request := func(body string) *http.Response {
		req, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(body))
		req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
		req.Header.Set("Idempotency-Key", "create-key-123456")
		response, requestErr := http.DefaultClient.Do(req)
		if requestErr != nil {
			t.Fatal(requestErr)
		}
		return response
	}
	response := request(`{"ticket_id":"ticket-1"}`)
	if response.StatusCode != http.StatusBadRequest {
		t.Fatalf("missing metadata status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	response = request(`{"ticket_id":"ticket-1","playlist":"invalid","client_build":"build-1","protocol_version":1}`)
	if response.StatusCode != http.StatusBadRequest {
		t.Fatalf("invalid playlist status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	response = request(`{"ticket_id":"ticket-1","playlist":"ranked","client_build":"build-1","protocol_version":7}`)
	if response.StatusCode != http.StatusCreated {
		t.Fatalf("valid metadata status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	if got.Playlist != domain.Ranked || got.ClientBuild != "build-1" || got.ProtocolVersion != 7 {
		t.Fatalf("provider received %+v", got)
	}
}

func TestQueueCreateRejectsCandidateMetadataMismatch(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, _ := sessions.Issue("player-1", time.Hour, now)
	service := &Service{Sessions: sessions, Queue: domain.NewQueue(), Now: func() time.Time { return now }, CandidateV2: func(_ string, ticketID string, spec domain.QueueSpec) (domain.Candidate, error) {
		spec.ClientBuild = "tampered"
		return domain.Candidate{PlayerID: "player-1", TicketID: ticketID, Playlist: spec.Playlist, ClientBuild: spec.ClientBuild, ProtocolVersion: spec.ProtocolVersion, EnqueuedAt: now}, nil
	}}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	req, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":"ticket-1","playlist":"ranked","client_build":"build-1","protocol_version":1}`))
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	req.Header.Set("Idempotency-Key", "create-key-123456")
	response, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusUnprocessableEntity {
		t.Fatalf("mismatch status = %d", response.StatusCode)
	}
}

func TestQueueRecoveryAPIIsAuthenticatedOwnerOnlyAndExpiresStaleTickets(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	ownerSession, ownerToken, err := sessions.Issue("player-1", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	otherSession, otherToken, err := sessions.Issue("player-2", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	queue := domain.NewQueue()
	service := &Service{Sessions: sessions, Queue: queue, Now: func() time.Time { return now }, Candidate: func(playerID, ticketID string) (domain.Candidate, error) {
		return domain.Candidate{PlayerID: playerID, TicketID: ticketID, EnqueuedAt: now}, nil
	}}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	create, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/queue", strings.NewReader(`{"ticket_id":"ticket-recovery-123456","playlist":"casual","client_build":"build-1","protocol_version":1}`))
	create.Header.Set("Authorization", "Bearer "+ownerSession.SessionID+":"+ownerToken)
	create.Header.Set("Idempotency-Key", "queue-create-recovery-123456")
	response, err := http.DefaultClient.Do(create)
	if err != nil || response.StatusCode != http.StatusCreated {
		t.Fatalf("create status=%v err=%v", response.StatusCode, err)
	}
	_ = response.Body.Close()
	get, _ := http.NewRequest(http.MethodGet, server.URL+"/v1/queue/ticket-recovery-123456", nil)
	get.Header.Set("Authorization", "Bearer "+ownerSession.SessionID+":"+ownerToken)
	response, err = http.DefaultClient.Do(get)
	if err != nil || response.StatusCode != http.StatusOK {
		t.Fatalf("owner recovery status=%v err=%v", response.StatusCode, err)
	}
	_ = response.Body.Close()
	get.Header.Set("Authorization", "Bearer "+otherSession.SessionID+":"+otherToken)
	response, err = http.DefaultClient.Do(get)
	if err != nil || response.StatusCode != http.StatusForbidden {
		t.Fatalf("cross-player recovery status=%v err=%v", response.StatusCode, err)
	}
	_ = response.Body.Close()
	service.Now = func() time.Time { return now.Add(domain.QueueExpiryWindow) }
	get.Header.Set("Authorization", "Bearer "+ownerSession.SessionID+":"+ownerToken)
	response, err = http.DefaultClient.Do(get)
	if err != nil || response.StatusCode != http.StatusGone {
		t.Fatalf("expired recovery status=%v err=%v", response.StatusCode, err)
	}
	_ = response.Body.Close()
}

func TestAuthenticatedProposalAPIUsesRevisionAndIdempotencyPolicy(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, err := sessions.Issue("player-a", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	proposal, err := domain.NewProposal("proposal-123456789", domain.Casual, []string{"player-a", "player-b"}, now)
	if err != nil {
		t.Fatal(err)
	}
	service := &Service{Sessions: sessions, Proposals: map[string]*domain.Proposal{proposal.ProposalID: &proposal}, Now: func() time.Time { return now }}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	req, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/proposals/"+proposal.ProposalID+"/accept", nil)
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	req.Header.Set("Idempotency-Key", "proposal-response-123456")
	req.Header.Set("If-Match-Revision", "0")
	response, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusOK {
		t.Fatalf("proposal accept status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
	req, _ = http.NewRequest(http.MethodPost, server.URL+"/v1/proposals/"+proposal.ProposalID+"/accept", nil)
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	req.Header.Set("Idempotency-Key", "proposal-response-654321")
	req.Header.Set("If-Match-Revision", "0")
	response, err = http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	if response.StatusCode != http.StatusConflict {
		t.Fatalf("stale proposal response status = %d", response.StatusCode)
	}
	_ = response.Body.Close()
}

func TestRankedProfileAPIReturnsBackendTierAndHidesCasualData(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, err := sessions.Issue("player-a", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	policy, err := domain.NewTierPolicy([]domain.TierBand{{Tier: domain.RankTierBronze, MinRating: 0}, {Tier: domain.RankTierGold, MinRating: 1500}})
	if err != nil {
		t.Fatal(err)
	}
	service := &Service{
		Sessions:       sessions,
		RankedProfiles: map[string]domain.RankedProfile{"player-a": {Rating: domain.Rating{Value: 1600, RD: 200, Volatility: 0.06}, RankedGames: 10, LastSeasonID: "season-1"}},
		TierPolicy:     policy,
		Now:            func() time.Time { return now },
	}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	req, _ := http.NewRequest(http.MethodGet, server.URL+"/v1/profile/ranked", nil)
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	response, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		t.Fatalf("ranked profile status = %d", response.StatusCode)
	}
	var body rankedProfileResponse
	if err := json.NewDecoder(response.Body).Decode(&body); err != nil {
		t.Fatal(err)
	}
	if body.Tier != string(domain.RankTierGold) || body.Provisional || body.RankedGames != 10 || body.SeasonID != "season-1" {
		t.Fatalf("ranked profile response = %+v", body)
	}
}

func TestProbeAPIUsesServerEvidenceAndRejectsClientRTTField(t *testing.T) {
	now := time.Unix(1000, 0).UTC()
	sessions := domain.NewSessionStore()
	session, token, err := sessions.Issue("player-a", time.Hour, now)
	if err != nil {
		t.Fatal(err)
	}
	called := false
	service := &Service{Sessions: sessions, Now: func() time.Time { return now }, Probe: func(playerID, region string, location, nonce []byte, receivedAt time.Time) (domain.ProbeEvidence, []byte, error) {
		called = true
		if playerID != "player-a" || region != "EU" || string(location) != "opaque" || string(nonce) != "nonce" || !receivedAt.Equal(now) {
			t.Fatalf("probe provider arguments = %q %s %q %q %v", playerID, region, location, nonce, receivedAt)
		}
		return domain.ProbeEvidence{OpaqueLocation: location, Nonce: nonce, IssuedAt: now, Region: region, ServerRTT: 40 * time.Millisecond}, nonce, nil
	}}
	server := httptest.NewServer(service.Handler())
	defer server.Close()
	request := `{"opaque_location":"b3BhcXVl","nonce":"bm9uY2U="}`
	req, _ := http.NewRequest(http.MethodPost, server.URL+"/v1/probes/EU", strings.NewReader(request))
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	response, err := http.DefaultClient.Do(req)
	if err != nil || response.StatusCode != http.StatusAccepted || !called {
		t.Fatalf("valid probe status=%v err=%v called=%v", response.StatusCode, err, called)
	}
	_ = response.Body.Close()
	request = `{"opaque_location":"b3BhcXVl","nonce":"bm9uY2U=","server_rtt_ms":1}`
	req, _ = http.NewRequest(http.MethodPost, server.URL+"/v1/probes/EU", strings.NewReader(request))
	req.Header.Set("Authorization", "Bearer "+session.SessionID+":"+token)
	response, err = http.DefaultClient.Do(req)
	if err != nil || response.StatusCode != http.StatusBadRequest {
		t.Fatalf("client RTT field status=%v err=%v", response.StatusCode, err)
	}
	_ = response.Body.Close()
}