package tests

import (
	"fmt"
	"time"

	authpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/auth"
	requestpb "git.techease.ru/Smart-search/smart-search-back/pkg/pb/request"
)

func (s *IntegrationSuite) TestIdempotency_DoubleCreateTZ_CreatesTwoRequests() {
	email, password, userID := s.createUniqueTestUser("idempotency_tz", 1000.0)

	loginResp, err := s.authClient.Login(s.ctx, &authpb.LoginRequest{
		Email:     email,
		Password:  password,
		Ip:        "127.0.0.1",
		UserAgent: "test-agent",
	})
	s.Require().NoError(err)

	validateResp, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: loginResp.AccessToken,
	})
	s.Require().NoError(err)

	requestText := "Одинаковый текст запроса для теста идемпотентности"

	resp1, err := s.requestClient.CreateTZ(s.ctx, &requestpb.CreateTZRequest{
		UserId:     validateResp.UserId,
		RequestTxt: requestText,
	})
	s.Require().NoError(err)
	requestID1 := resp1.RequestId

	resp2, err := s.requestClient.CreateTZ(s.ctx, &requestpb.CreateTZRequest{
		UserId:     validateResp.UserId,
		RequestTxt: requestText,
	})
	s.Require().NoError(err)
	requestID2 := resp2.RequestId

	s.T().Logf("Request 1 ID: %s", requestID1)
	s.T().Logf("Request 2 ID: %s", requestID2)

	s.NotEqual(requestID1, requestID2,
		"Два вызова CreateTZ должны создать два разных request")

	var requestCount int
	err = s.pool.QueryRow(s.ctx,
		"SELECT COUNT(*) FROM requests_for_suppliers WHERE user_id = $1 AND request_txt = $2",
		userID, requestText,
	).Scan(&requestCount)
	s.NoError(err)

	s.Equal(2, requestCount,
		"Должно быть создано 2 запроса с одинаковым текстом")
}

func (s *IntegrationSuite) TestIdempotency_DoubleRegister_SameInviteCode() {
	inviteCode := s.createActiveInviteCode(5)

	email1 := fmt.Sprintf("double_reg1_%d@example.com", time.Now().UnixNano())

	resp1, err := s.authClient.Register(s.ctx, &authpb.RegisterRequest{
		Email:      email1,
		Password:   "testpassword",
		Name:       "User 1",
		Phone:      fmt.Sprintf("+1%010d", time.Now().UnixNano()%10000000000),
		InviteCode: inviteCode,
		Ip:         "127.0.0.1",
		UserAgent:  "test-agent",
	})
	s.Require().NoError(err)
	s.NotEmpty(resp1.AccessToken)

	email2 := fmt.Sprintf("double_reg2_%d@example.com", time.Now().UnixNano())

	resp2, err := s.authClient.Register(s.ctx, &authpb.RegisterRequest{
		Email:      email2,
		Password:   "testpassword",
		Name:       "User 2",
		Phone:      fmt.Sprintf("+2%010d", time.Now().UnixNano()%10000000000),
		InviteCode: inviteCode,
		Ip:         "127.0.0.1",
		UserAgent:  "test-agent",
	})
	s.Require().NoError(err)
	s.NotEmpty(resp2.AccessToken)

	remainingUses := s.getInviteCodeUsageCount(inviteCode)
	s.T().Logf("Remaining invite uses: %d", remainingUses)

	s.Equal(3, remainingUses,
		"После двух регистраций должно остаться 3 использования (5-2)")

	validate1, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: resp1.AccessToken,
	})
	s.NoError(err)

	validate2, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: resp2.AccessToken,
	})
	s.NoError(err)

	s.NotEqual(validate1.UserId, validate2.UserId,
		"Должны быть созданы два разных пользователя")
}

func (s *IntegrationSuite) TestIdempotency_DoubleLogout_SameToken() {
	email, password, _ := s.createUniqueTestUser("double_logout", 100.0)

	loginResp, err := s.authClient.Login(s.ctx, &authpb.LoginRequest{
		Email:     email,
		Password:  password,
		Ip:        "127.0.0.1",
		UserAgent: "test-agent",
	})
	s.Require().NoError(err)
	accessToken := loginResp.AccessToken

	validateBefore, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: accessToken,
	})
	s.NoError(err)
	s.True(validateBefore.Valid)

	logout1, err := s.authClient.Logout(s.ctx, &authpb.LogoutRequest{
		AccessToken: accessToken,
	})
	s.NoError(err)
	s.True(logout1.Success)

	validateAfter1, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: accessToken,
	})
	s.NoError(err)
	s.False(validateAfter1.Valid,
		"Токен должен быть невалиден после первого logout")

	logout2, err := s.authClient.Logout(s.ctx, &authpb.LogoutRequest{
		AccessToken: accessToken,
	})
	s.NoError(err)
	s.True(logout2.Success,
		"Повторный logout должен быть успешным (идемпотентность)")

	validateAfter2, err := s.authClient.Validate(s.ctx, &authpb.ValidateRequest{
		AccessToken: accessToken,
	})
	s.NoError(err)
	s.False(validateAfter2.Valid,
		"Токен должен оставаться невалидным после повторного logout")
}