//go:build end2end
// +build end2end

package end2end

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/http/httptest"
	"testing"

	"git.gocasts.ir/ebhomengo/niki/delivery/http_server/end2end/setup"
	"git.gocasts.ir/ebhomengo/niki/entity"
	adminserviceparam "git.gocasts.ir/ebhomengo/niki/param/admin/admin"
	adminParam "git.gocasts.ir/ebhomengo/niki/param/admin/kind_box"
	agentParam "git.gocasts.ir/ebhomengo/niki/param/agent/kind_box"
	"github.com/labstack/echo/v4"
	"github.com/stretchr/testify/assert"
)

const (
	agent1PhoneNumber      = "09384664403"
	agent1Password         = "Abc123456"
	agent1ID          uint = 4
	agent2PhoneNumber      = "09384664404"
	agent2Password         = "Abc123456"
	agent2ID          uint = 5
)

func TestAgent_KindBox_Get(t *testing.T) {
	t.Run("basic", Agent_KindBox_Get_Basic)
	t.Run("no token", Agent_KindBox_Get_NoToken)
}

func Agent_KindBox_Get_Basic(t *testing.T) {
	kindBox := entity.KindBox{
		ID:              2,
		SerialNumber:    "serial-2",
		ReceiverAgentID: agent1ID,
		Status:          entity.KindBoxAssignedReceiverAgentStatus,
	}
	url := fmt.Sprintf("/agents/kindboxes/%d", kindBox.ID)

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	token, err := getToken(agent1PhoneNumber, agent1Password)
	if err != nil {
		t.Fatalf("could not login: %s", err)
	}

	resRecord := createRequest(http.MethodGet, url, token, nil)
	var res agentParam.GetKindBoxResponse
	err = json.NewDecoder(resRecord.Body).Decode(&res)
	assert.NoError(t, err, "could not decode response body")

	assert.Equal(t, http.StatusOK, resRecord.Code)
	assert.Equal(t, kindBox.ID, res.ID)
	assert.Equal(t, kindBox.ReceiverAgentID, res.ReceiverAgentID)
	assert.Equal(t, kindBox.SerialNumber, res.SerialNumber)
	assert.Equal(t, kindBox.Status, res.Status)
}

func Agent_KindBox_Get_NoToken(t *testing.T) {
	const kindBoxID = 2
	url := fmt.Sprintf("/agents/kindboxes/%d", kindBoxID)

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	resRecord := createRequest(http.MethodGet, url, "", nil)

	assert.Equal(t, http.StatusUnauthorized, resRecord.Code)
}

func TestAgent_KindBox_Return(t *testing.T) {
	t.Run("basic", Agent_KindBox_Return_Basic)
	t.Run("no token", Agent_KindBox_Return_NoToken)
	t.Run("wrong agent", Agent_KindBox_Return_WrongAgent)
}

func Agent_KindBox_Return_Basic(t *testing.T) {
	kindBoxReqBody := agentParam.ReturnKindBoxRequest{SerialNumber: "new-serial"}
	const kindBoxID uint = 2
	url := fmt.Sprintf("/agents/kindboxes/return/%d", kindBoxID)

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	token, err := getToken(agent1PhoneNumber, agent1Password)
	if err != nil {
		t.Fatalf("could not login: %s", err)
	}

	resRecord := createRequest(http.MethodPatch, url, token, kindBoxReqBody)
	updatedKindBox, err := services.AdminKindBoxSvc.Get(
		context.Background(),
		adminParam.KindBoxGetRequest{KindBoxID: kindBoxID},
	)

	assert.Equal(t, http.StatusNoContent, resRecord.Code)
	assert.Equal(t, kindBoxReqBody.SerialNumber, updatedKindBox.SerialNumber)
	assert.Equal(t, agent1ID, updatedKindBox.ReceiverAgentID)
	assert.Equal(t, entity.KindBoxReturnedStatus, updatedKindBox.Status)
}

func Agent_KindBox_Return_NoToken(t *testing.T) {
	const kindBoxID = 2
	url := fmt.Sprintf("/agents/kindboxes/return/%d", kindBoxID)

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	resRecord := createRequest(http.MethodGet, url, "", nil)

	assert.Equal(t, http.StatusUnauthorized, resRecord.Code)
}

func Agent_KindBox_Return_WrongAgent(t *testing.T) {
	kindBoxReqBody := agentParam.ReturnKindBoxRequest{SerialNumber: "new-serial"}
	const kindBoxID uint = 2
	url := fmt.Sprintf("/agents/kindboxes/return/%d", kindBoxID)

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	token, err := getToken(agent2PhoneNumber, agent2Password)
	if err != nil {
		t.Fatalf("could not login: %s", err)
	}

	resRecord := createRequest(http.MethodPatch, url, token, kindBoxReqBody)
	assert.Equal(t, http.StatusUnprocessableEntity, resRecord.Code)
}

func getToken(phoneNumber, password string) (string, error) {
	res, err := services.AdminSvc.LoginWithPhoneNumber(
		context.Background(),
		adminserviceparam.LoginWithPhoneNumberRequest{
			PhoneNumber: phoneNumber,
			Password:    password,
		},
	)
	if err != nil {
		return "", err
	}
	return res.Tokens.AccessToken, nil
}

func TestAgent_KindBox_Get_All(t *testing.T) {
	t.Run("basic", Agent_kindBox_Get_All_Basic)
	t.Run("no token", Agent_kindBox_Get_All_NoToken)
}

func Agent_kindBox_Get_All_Basic(t *testing.T) {
	kindBoxesCount := 1

	url := "/agents/kindboxes"

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	token, err := getToken(agent1PhoneNumber, agent1Password)
	if err != nil {
		t.Fatalf("could not login: %s", err)
	}

	resRecord := createRequest(http.MethodGet, url, token, nil)
	var res agentParam.GetAllResponse
	err = json.NewDecoder(resRecord.Body).Decode(&res)
	assert.NoError(t, err, "could not decode response body")

	assert.Equal(t, http.StatusOK, resRecord.Code)
	assert.Equal(t, kindBoxesCount, len(res.AllKindBoxes))
}

func Agent_kindBox_Get_All_NoToken(t *testing.T) {
	url := "/agents/kindboxes"

	teardown := setup.SeedMariaDB(testContainer.GetMariaDBConfig())
	t.Cleanup(teardown)

	resRecord := createRequest(http.MethodGet, url, "", nil)

	assert.Equal(t, http.StatusUnauthorized, resRecord.Code)
}

func createRequest(
	method string,
	url string,
	token string,
	body any,
) *httptest.ResponseRecorder {
	var buf bytes.Buffer
	if body != nil {
		err := json.NewEncoder(&buf).Encode(body)
		if err != nil {
			log.Fatalf("could not encode body: %v", err)
		}
	}

	req := httptest.NewRequest(method, url, &buf)
	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
	req.Header.Set(echo.HeaderAuthorization, fmt.Sprintf("Bearer %s", token))
	res := httptest.NewRecorder()

	// Serve the request
	testServer.Serve(res, req)
	return res
}