//nolint:dupl
package delete

import (
	"context"
	"encoding/json"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/require"

	"edge-infra.dev/pkg/edge/api/fake"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/edgecli"
	"edge-infra.dev/pkg/edge/edgecli/flagutil"
	"edge-infra.dev/pkg/lib/cli/rags"
)

type DeleteOperatorInterventionPrivilegeResponse struct {
	DeleteOperatorInterventionPrivilege model.DeleteOperatorInterventionPrivilegeResponse `json:"deleteOperatorInterventionPrivilege"`
}

// Mocks the DeleteOperatorInterventionPrivilegeResponse. Returns an error
// response when the privilege `bad-privilege` is sent, otherwise returns a
// non-error response
func DeleteOperatorInterventionPrivilege(body []byte) (interface{}, bool, error) {
	if !strings.Contains(string(body), "deleteOperatorInterventionPrivilege(privilege: $privilege)") {
		return nil, false, nil
	}

	var ok = true

	var m struct {
		Query     string
		Variables struct {
			Privilege struct {
				Name string
			}
		}
	}
	err := json.Unmarshal(body, &m)
	if err != nil {
		return DeleteOperatorInterventionPrivilegeResponse{}, ok, nil
	}

	var errors []*model.OperatorInterventionErrorResponse
	if m.Variables.Privilege.Name == "bad-privilege" {
		errors = []*model.OperatorInterventionErrorResponse{{
			Type:      model.OperatorInterventionErrorTypeUnknownCommand,
			Privilege: &m.Variables.Privilege.Name,
		}}
	}
	return DeleteOperatorInterventionPrivilegeResponse{
		DeleteOperatorInterventionPrivilege: model.DeleteOperatorInterventionPrivilegeResponse{
			Errors: errors,
		},
	}, ok, nil
}

func TestDeletePrivilege(t *testing.T) {
	t.Parallel()

	edgeAPIMockSvr := fake.GetMockAPIServer(DeleteOperatorInterventionPrivilege)
	edgeAPIMockURL := edgeAPIMockSvr.URL + "/api/v2"
	t.Cleanup(func() {
		edgeAPIMockSvr.Close()
	})

	tests := map[string]struct {
		flagsFunc func(*rags.RagSet) error
		expError  require.ErrorAssertionFunc
	}{
		"No Flags": {
			flagsFunc: func(*rags.RagSet) error { return nil },
			expError:  require.Error,
		},
		"Empty Flag": {
			flagsFunc: func(c *rags.RagSet) error {
				return flagutil.SetFlag(c, flagutil.OIPrivilege, "")
			},
			expError: require.Error,
		},
		"Flag": {
			flagsFunc: func(c *rags.RagSet) error {
				return flagutil.SetFlag(c, flagutil.OIPrivilege, "abcd")
			},
			expError: require.NoError,
		},
		"Bad Command": {
			flagsFunc: func(c *rags.RagSet) error {
				return flagutil.SetFlag(c, flagutil.OIPrivilege, "bad-privilege")
			},
			expError: require.Error,
		},
	}

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

			// Set a dummy token in a fake banner context so that we bypass the
			// ValidateConnectionFlags check which would otherwise do a login
			// mutation to the api server, something which is not supported by
			// the fake server
			future := time.Now().Add(time.Hour * 24)
			testConfig := edgecli.Config{
				CurrentBannerContext: "fakeBanner",
				BannerContexts: map[string]*edgecli.BannerContext{
					"fakeBanner": {
						TokenTime: future.Format(time.RFC3339),
						Token:     "fakeToken",
						Endpoint:  edgeAPIMockURL,
					},
				},
			}

			cmd := NewDeletePrivilege(&testConfig)
			cmd.Command() // Required to initialise cmd.Rags

			require.NoError(t, tc.flagsFunc(cmd.Rags))

			err := cmd.Command().Exec(context.Background(), []string{})
			tc.expError(t, err)
		})
	}
}