package bsl

import (
	"context"
	"testing"

	"edge-infra.dev/pkg/edge/api/bsl/types"
	bsltypes "edge-infra.dev/pkg/edge/api/bsl/types"
	"edge-infra.dev/pkg/edge/auth-proxy/session"

	"github.com/stretchr/testify/assert"
)

const (
	nameNoSlash               = "testorg"
	nameWithSlash             = "/testorg/"
	multiLevelOrg             = "/customers/testorg/"
	multiLevelOrgNoSlash      = "customers/testorg"
	superMultiLevelOrg        = "/tests/customers/testorg/"
	superMultiLevelOrgNoSlash = "tests/customers/testorg"
	superDuperMultiLevelOrg   = "/customers/edge-dev1-retail-b526aa/testorg/"
	fourLevelOrg              = "/customers/edge-dev1-retail-b526aa/testorg/hello/"
	tenantName                = "edge-dev1-retail-b526aa"
)

func TestGetOrgShortName(t *testing.T) {
	assert.Equal(t, nameNoSlash, GetOrgShortName(nameNoSlash))

	assert.Equal(t, nameNoSlash, GetOrgShortName(nameWithSlash))

	assert.Equal(t, nameNoSlash, GetOrgShortName(multiLevelOrg))

	assert.Equal(t, nameNoSlash, GetOrgShortName(multiLevelOrgNoSlash))

	assert.Equal(t, nameNoSlash, GetOrgShortName(superMultiLevelOrg))

	assert.Equal(t, nameNoSlash, GetOrgShortName(superMultiLevelOrgNoSlash))

	assert.Equal(t, nameNoSlash, GetOrgShortName(superDuperMultiLevelOrg))
}

func TestGetFullAccountName(t *testing.T) {
	testUser := "testuser"
	expectedAccount := "acct:testorg@testuser"
	nameNoSlash := "testorg"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: nameNoSlash, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))

	nameWithSlash := "/testorg/"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: nameWithSlash, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))

	multiLevelOrg := "/customers/testorg/"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: multiLevelOrg, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))

	multiLevelOrgNoSlash := "customers/testorg"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: multiLevelOrgNoSlash, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))

	superMultiLevelOrg := "/tests/customers/testorg/"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: superMultiLevelOrg, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))

	superMultiLevelOrgNoSlash := "tests/customers/testorg"
	assert.Equal(t, expectedAccount, CreateFullAccountName(&types.AuthUser{Organization: superMultiLevelOrgNoSlash, Username: testUser, AuthProvider: session.BSLAuthProvider.String()}))
}

func TestWithOrganizationPrefix(t *testing.T) {
	cfg := bsltypes.BSPConfig{OrganizationPrefix: "edge-stage1-"}

	assert.Equal(t, "edge-stage1-testorg", WithOrganizationPrefix(cfg, nameNoSlash))

	assert.Equal(t, "/edge-stage1-testorg/", WithOrganizationPrefix(cfg, nameWithSlash))

	assert.Equal(t, "/customers/edge-stage1-testorg/", WithOrganizationPrefix(cfg, multiLevelOrg))

	assert.Equal(t, "/tests/customers/edge-stage1-testorg/", WithOrganizationPrefix(cfg, superMultiLevelOrg))
}

func TestWithOrganizationPrefixEmpty(t *testing.T) {
	cfg := bsltypes.BSPConfig{OrganizationPrefix: ""}

	assert.Equal(t, nameNoSlash, WithOrganizationPrefix(cfg, nameNoSlash))

	assert.Equal(t, nameWithSlash, WithOrganizationPrefix(cfg, nameWithSlash))

	assert.Equal(t, multiLevelOrg, WithOrganizationPrefix(cfg, multiLevelOrg))

	assert.Equal(t, superMultiLevelOrg, WithOrganizationPrefix(cfg, superMultiLevelOrg))
}

func TestTrimOrg(t *testing.T) {
	tenant := GetTenant("/customers/", superDuperMultiLevelOrg)
	assert.Equal(t, tenant, tenantName)
	tenant = GetTenant("/customers/", fourLevelOrg)
	assert.Equal(t, tenant, tenantName)
}

func TestHTTPClient_WithOrg_EmptyRoot(t *testing.T) {
	cfg := bsltypes.BSPConfig{Root: ""}
	cl := NewBSLClient(cfg).request(context.Background())

	assertOrgHeader(t, cl, nameWithSlash)
}

func TestHTTPClient_WithOrg(t *testing.T) {
	cfg := bsltypes.BSPConfig{Root: "/customers/"}
	cl := NewBSLClient(cfg).request(context.Background())

	assertOrgHeader(t, cl, multiLevelOrg)
}

func assertOrgHeader(t *testing.T, cl *Request, levelOne string) {
	cl.SetOrg(nameNoSlash)
	assert.Equal(t, levelOne, cl.Header.Get(NepOrganization))

	cl.SetOrg(nameWithSlash)
	assert.Equal(t, levelOne, cl.Header.Get(NepOrganization))

	cl.SetOrg(multiLevelOrg)
	assert.Equal(t, multiLevelOrg, cl.Header.Get(NepOrganization))

	cl.SetOrg(multiLevelOrgNoSlash)
	assert.Equal(t, multiLevelOrg, cl.Header.Get(NepOrganization))

	cl.SetOrg(superMultiLevelOrg)
	assert.Equal(t, superMultiLevelOrg, cl.Header.Get(NepOrganization))

	cl.SetOrg(superMultiLevelOrgNoSlash)
	assert.Equal(t, superMultiLevelOrg, cl.Header.Get(NepOrganization))
}