package client

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/shurcooL/graphql"
	"github.com/stretchr/testify/assert"

	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/auth-proxy/utils"
)

const (
	username     = "johndoe"
	familyName   = "Doe"
	givenName    = "John"
	fullName     = "John Doe"
	status       = "Active"
	password     = "123456"
	organization = "test-org"
)

func TestNew(t *testing.T) {
	cl, err := New()
	assert.NoError(t, err)
	assert.NotEmpty(t, cl)
}

func TestQuery(t *testing.T) {
	res := &utils.Response{
		Data: model.User{
			Username:   username,
			FamilyName: familyName,
			GivenName:  givenName,
			FullName:   fullName,
			Status:     status,
		},
	}
	resp, err := json.Marshal(res)
	assert.NoError(t, err)
	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, err := w.Write(resp)
		assert.NoError(t, err)
	}))
	defer svr.Close()
	cl, err := New(WithBaseURL(svr.URL))
	assert.NoError(t, err)
	assert.NotEmpty(t, cl)
	var userQuery struct {
		model.User `graphql:"user(username: $username)"`
	}
	assert.NoError(t, cl.Query(context.Background(), &userQuery, map[string]any{
		"username": graphql.String(username),
	}))
	assert.Equal(t, username, userQuery.Username)
	assert.Equal(t, familyName, userQuery.FamilyName)
	assert.Equal(t, givenName, userQuery.GivenName)
	assert.Equal(t, fullName, userQuery.FullName)
	assert.Equal(t, status, userQuery.Status)
}

func TestMutate(t *testing.T) {
	res := &utils.Response{
		Data: model.AuthPayload{
			Token:              "test-token",
			FullName:           fullName,
			Roles:              []string{"EDGE_ORG_ADMIN"},
			Organization:       organization,
			CredentialsExpired: false,
		},
	}
	resp, err := json.Marshal(res)
	assert.NoError(t, err)
	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, err := w.Write(resp)
		assert.NoError(t, err)
	}))
	defer svr.Close()
	cl, err := New(WithBaseURL(svr.URL))
	assert.NoError(t, err)
	assert.NotEmpty(t, cl)
	var loginMutation struct {
		model.AuthPayload `graphql:"login(username: $username, password: $password, organization: $organization)"`
	}
	assert.NoError(t, cl.Mutate(context.Background(), &loginMutation, map[string]any{
		"username":     graphql.String(username),
		"password":     graphql.String(password),
		"organization": graphql.String(organization),
	}))
}

func TestHandleRefresh(t *testing.T) {
	res := &utils.Response{
		Data: SessionRefreshResponse{
			Token: "test-token",
		},
	}
	resp, err := json.Marshal(res)
	assert.NoError(t, err)
	svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.WriteHeader(http.StatusOK)
		_, err := w.Write(resp)
		assert.NoError(t, err)
	}))
	defer svr.Close()
	cl, err := New(WithBaseURL(svr.URL))
	assert.NoError(t, err)
	assert.NotEmpty(t, cl)
	assert.NoError(t, cl.handleRefresh(context.Background()))
}