//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 DeleteOperatorInterventionRoleMappingResponse struct {
	DeleteOperatorInterventionRoleMapping model.DeleteOperatorInterventionResponse `json:"deleteOperatorInterventionRoleMapping"`
}

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

	var ok = true

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

	var errors []*model.OperatorInterventionErrorResponse
	if m.Variables.Mapping.Role == "bad-role" {
		errors = []*model.OperatorInterventionErrorResponse{{
			Type:      model.OperatorInterventionErrorTypeUnknownRoleMapping,
			Role:      &m.Variables.Mapping.Role,
			Privilege: &m.Variables.Mapping.Privilege.Name,
		}}
	}
	return DeleteOperatorInterventionRoleMappingResponse{
		DeleteOperatorInterventionRoleMapping: model.DeleteOperatorInterventionResponse{
			Errors: errors,
		},
	}, ok, nil
}

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

	edgeAPIMockSvr := fake.GetMockAPIServer(DeleteOperatorInterventionRoleMapping)
	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 Role Flag": {
			flagsFunc: func(rs *rags.RagSet) error {
				return flagutil.SetFlag(rs, flagutil.OIRole, "abcd")
			},
			expError: require.Error,
		},
		"Only Privilege Flag": {
			flagsFunc: func(rs *rags.RagSet) error {
				return flagutil.SetFlag(rs, flagutil.OIPrivilege, "efgh")
			},
			expError: require.Error,
		},
		"All flags": {
			flagsFunc: func(rs *rags.RagSet) error {
				return errors.Join(
					flagutil.SetFlag(rs, flagutil.OIRole, "abcd"),
					flagutil.SetFlag(rs, flagutil.OIPrivilege, "efgh"),
				)
			},
			expError: require.NoError,
		},
		"Unknown role mapping": {
			flagsFunc: func(rs *rags.RagSet) error {
				return errors.Join(
					flagutil.SetFlag(rs, flagutil.OIRole, "bad-role"),
					flagutil.SetFlag(rs, flagutil.OIPrivilege, "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 := NewDeleteRoleMapping(&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)
		})
	}
}