package main

import (
	"bytes"
	"encoding/json"
	"github.com/stretchr/testify/assert"
	"go-nkode/core"
	"io"
	"net/http"
	"testing"
)

func TestApi(t *testing.T) {
	base := "http://localhost:8080"
	newCustomerBody := core.NewCustomerPost{
		NKodePolicy: core.NewDefaultNKodePolicy(),
	}
	kp := core.KeypadDimension{
		AttrsPerKey: 14,
		NumbOfKeys:  10,
	}
	var customerResp core.CreateNewCustomerResp
	testApiPost(t, base+core.CreateNewCustomer, newCustomerBody, &customerResp)

	username := core.Username("test_username")
	signupInterfaceBody := core.GenerateSignupInterfacePost{
		CustomerId:  customerResp.CustomerId,
		AttrsPerKey: kp.AttrsPerKey,
		NumbOfKeys:  kp.NumbOfKeys,
		Username:    username,
	}
	var signupInterfaceResp core.GenerateSignupInterfaceResp
	testApiPost(t, base+core.GenerateSignupInterface, signupInterfaceBody, &signupInterfaceResp)
	assert.Len(t, signupInterfaceResp.SvgInterface, kp.TotalAttrs())
	passcodeLen := 4
	setInterface := signupInterfaceResp.UserIdxInterface
	userPasscode := setInterface[:passcodeLen]
	kp_set := core.KeypadDimension{NumbOfKeys: kp.NumbOfKeys, AttrsPerKey: kp.NumbOfKeys}
	setKeySelection, err := core.SelectKeyByAttrIdx(setInterface, userPasscode, kp_set)
	assert.NoError(t, err)
	setNKodeBody := core.SetNKodePost{
		CustomerId:   customerResp.CustomerId,
		SessionId:    signupInterfaceResp.SessionId,
		KeySelection: setKeySelection,
	}
	var setNKodeResp core.SetNKodeResp
	testApiPost(t, base+core.SetNKode, setNKodeBody, &setNKodeResp)
	confirmInterface := setNKodeResp.UserInterface
	confirmKeySelection, err := core.SelectKeyByAttrIdx(confirmInterface, userPasscode, kp_set)
	assert.NoError(t, err)
	confirmNKodeBody := core.ConfirmNKodePost{
		CustomerId:   customerResp.CustomerId,
		KeySelection: confirmKeySelection,
		SessionId:    signupInterfaceResp.SessionId,
	}
	testApiPost(t, base+core.ConfirmNKode, confirmNKodeBody, nil)

	loginInterfaceBody := core.GetLoginInterfacePost{
		CustomerId: customerResp.CustomerId,
		Username:   username,
	}

	var loginInterfaceResp core.GetLoginInterfaceResp
	testApiPost(t, base+core.GetLoginInterface, loginInterfaceBody, &loginInterfaceResp)
	assert.Equal(t, loginInterfaceResp.AttrsPerKey, kp.AttrsPerKey)
	assert.Equal(t, loginInterfaceResp.NumbOfKeys, kp.NumbOfKeys)
	loginKeySelection, err := core.SelectKeyByAttrIdx(loginInterfaceResp.UserIdxInterface, userPasscode, kp)
	assert.NoError(t, err)
	loginBody := core.LoginPost{
		CustomerId:   customerResp.CustomerId,
		Username:     username,
		KeySelection: loginKeySelection,
	}
	var jwtTokens core.JwtTokens
	testApiPost(t, base+core.Login, loginBody, &jwtTokens)
	refreshClaims, err := core.ParseRefreshToken(jwtTokens.RefreshToken)
	assert.Equal(t, refreshClaims.Subject, string(username))
	accessClaims, err := core.ParseRefreshToken(jwtTokens.AccessToken)
	assert.Equal(t, accessClaims.Subject, string(username))
	renewBody := core.RenewAttributesPost{CustomerId: customerResp.CustomerId}
	testApiPost(t, base+core.RenewAttributes, renewBody, nil)

	loginKeySelection, err = core.SelectKeyByAttrIdx(loginInterfaceResp.UserIdxInterface, userPasscode, kp)
	assert.NoError(t, err)
	loginBody = core.LoginPost{
		CustomerId:   customerResp.CustomerId,
		Username:     username,
		KeySelection: loginKeySelection,
	}

	testApiPost(t, base+core.Login, loginBody, &jwtTokens)

	var randomSvgInterfaceResp core.RandomSvgInterfaceResp
	testApiGet(t, base+core.RandomSvgInterface, &randomSvgInterfaceResp)
	assert.Equal(t, core.KeypadMax.TotalAttrs(), len(randomSvgInterfaceResp.Svgs))

	refreshBody := core.RefreshTokenPost{
		Username:     string(username),
		CustomerId:   customerResp.CustomerId,
		RefreshToken: jwtTokens.RefreshToken,
	}

	var refreshTokenResp core.RefreshTokenResp
	testApiPost(t, base+core.RefreshToken, refreshBody, &refreshTokenResp)
	accessClaims, err = core.ParseAccessToken(refreshTokenResp.AccessToken)
	assert.NoError(t, err)
	assert.Equal(t, accessClaims.Subject, string(username))
}

func Unmarshal(t *testing.T, resp *http.Response, data any) {
	responseBody, err := io.ReadAll(resp.Body)
	assert.NoError(t, err)
	err = json.Unmarshal(responseBody, data)
	assert.NoError(t, err)
}

func Marshal(t *testing.T, data any) *bytes.Reader {
	jsonBytes, err := json.Marshal(data)
	assert.NoError(t, err)
	reader := bytes.NewReader(jsonBytes)
	return reader
}

func testApiPost(t *testing.T, endpointStr string, postBody any, respBody any) {
	reader := Marshal(t, postBody)
	resp, err := http.Post(endpointStr, "application/json", reader)
	assert.NoError(t, err)
	assert.Equal(t, resp.StatusCode, http.StatusOK)
	if respBody != nil {
		Unmarshal(t, resp, respBody)
	}
}

func testApiGet(t *testing.T, endpointStr string, respBody any) {
	resp, err := http.Get(endpointStr)
	assert.NoError(t, err)
	assert.Equal(t, resp.StatusCode, http.StatusOK)
	if respBody != nil {
		Unmarshal(t, resp, respBody)
	}
}