package server

import (
	"context"
	_ "embed"
	"io"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
)

func getTestGinContext(r *httptest.ResponseRecorder) (*gin.Context, *gin.Engine) {
	gin.SetMode(gin.TestMode)
	ctx, ginEngine := gin.CreateTestContext(r)
	return ctx, ginEngine
}

type mockUserService struct {
	Service

	roles []string

	res []string
	err error
}

func (us *mockUserService) GetEARoles(_ context.Context, roles []string) ([]string, error) {
	us.roles = roles
	return us.res, us.err
}

func TestServerEARoles(t *testing.T) {
	tests := map[string]struct {
		query string

		mock mockUserService

		expRoles []string

		expResult string
		expCode   int
	}{
		"Single role query": {
			query: "/eaRoles?role=level2",
			mock: mockUserService{
				res: []string{"ea-basic"},
				err: nil,
			},
			expRoles:  []string{"level2"},
			expResult: `["ea-basic"]`,
			expCode:   200,
		},
		"Standard ea-role mapping": {
			query: "/eaRoles?role=level2&role=level3",
			mock: mockUserService{
				res: []string{"ea-basic"},
				err: nil,
			},
			expRoles:  []string{"level2", "level3"},
			expResult: `["ea-basic"]`,
			expCode:   200,
		},
		"Admin ea-role mapping": {
			query: "/eaRoles?role=level2&role=level1",
			mock: mockUserService{
				res: []string{"ea-basic", "ea-admin"},
				err: nil,
			},
			expRoles:  []string{"level2", "level1"},
			expResult: `["ea-basic", "ea-admin"]`,
			expCode:   200,
		},
		"Missing ea-role query": {
			query: "/eaRoles",
			mock: mockUserService{
				res: []string{},
				err: nil,
			},
			expResult: `[]`,
			expCode:   200,
		},
		"Unknown ea-role mapping": {
			query: "/eaRoles?role=l2",
			mock: mockUserService{
				res: []string{},
				err: nil,
			},
			expRoles:  []string{"l2"},
			expResult: `[]`,
			expCode:   200,
		},
	}

	for name, tc := range tests {
		tc := tc
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			r := httptest.NewRecorder()

			_, ginEngine := getTestGinContext(r)

			_, err := NewUserService(ginEngine, &tc.mock, newLogger())
			assert.NoError(t, err)

			req, err := http.NewRequest(http.MethodGet, tc.query, nil)
			assert.NoError(t, err)

			ginEngine.ServeHTTP(r, req)

			response := r.Result()
			assert.Equal(t, tc.expCode, response.StatusCode)

			data, err := io.ReadAll(r.Body)
			assert.NoError(t, err)

			assert.JSONEq(t, tc.expResult, string(data))

			assert.Equal(t, tc.expRoles, tc.mock.roles)
		})
	}
}