//nolint:dupl
package delete

import (
	"context"
	"encoding/json"
	"errors"
	"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 DeleteOperatorInterventionRuleResponse struct {
	DeleteCommandFromOperatorInterventionRule model.DeleteOperatorInterventionRuleResponse `json:"deleteCommandFromOperatorInterventionRule"`
}

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

	// This callback should handle the response
	var ok = true

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

	var errors []*model.OperatorInterventionErrorResponse
	if m.Variables.Rule.Privilege == "bad-privilege" {
		errors = []*model.OperatorInterventionErrorResponse{{
			Type:      model.OperatorInterventionErrorTypeUnknownRule,
			Privilege: &m.Variables.Rule.Privilege,
			Command:   &m.Variables.Rule.Command,
		}}
	}
	return DeleteOperatorInterventionRuleResponse{
		DeleteCommandFromOperatorInterventionRule: model.DeleteOperatorInterventionRuleResponse{
			Errors: errors,
		},
	}, ok, nil
}

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

	edgeAPIMockSvr := fake.GetMockAPIServer(DeleteCommandFromOperatorInterventionRule)
	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,
		},
		"Only privilege flag": {
			flagsFunc: func(c *rags.RagSet) error {
				return flagutil.SetFlag(c, flagutil.OIPrivilege, "abcd")
			},
			expError: require.Error,
		},
		"Only command flag": {
			flagsFunc: func(c *rags.RagSet) error {
				return flagutil.SetFlag(c, flagutil.OICommand, "abcd")
			},
			expError: require.Error,
		},
		"Delete with no errors": {
			flagsFunc: func(c *rags.RagSet) error {
				return errors.Join(
					flagutil.SetFlag(c, flagutil.OIPrivilege, "abcd"),
					flagutil.SetFlag(c, flagutil.OICommand, "efgh"),
				)
			},
			expError: require.NoError,
		},
		"Delete returned error": {
			flagsFunc: func(c *rags.RagSet) error {
				return errors.Join(
					flagutil.SetFlag(c, flagutil.OIPrivilege, "bad-privilege"),
					flagutil.SetFlag(c, flagutil.OICommand, "efgh"),
				)
			},
			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 := NewDeleteRule(&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)
		})
	}
}