package share

import (
	"testing"

	"git.entityseven.com/rilaxik/pllist/internal/domain"
)

func TestShareCallbackRoundTrips(t *testing.T) {
	listID, role, err := parseRole(roleData(42, domain.RoleEditor))
	if err != nil || listID != 42 || role != domain.RoleEditor {
		t.Fatalf("parseRole() = %d, %q, %v", listID, role, err)
	}

	for _, pending := range []bool{false, true} {
		want := shareRef{listID: 42, shareID: 7, pending: pending}

		ref, err := parseView(viewData(42, 7, pending))
		if err != nil {
			t.Fatalf("parseView() error = %v", err)
		}
		if ref != want {
			t.Fatalf("parseView() = %+v, want %+v", ref, want)
		}

		ref, role, err := parseSet(setData(42, 7, pending, domain.RoleReader))
		if err != nil || role != domain.RoleReader {
			t.Fatalf("parseSet() = %+v, %q, %v", ref, role, err)
		}
		if ref != want {
			t.Fatalf("parseSet() ref = %+v, want %+v", ref, want)
		}

		ref, err = parseRevoke(revokeData(42, 7, pending))
		if err != nil {
			t.Fatalf("parseRevoke() error = %v", err)
		}
		if ref != want {
			t.Fatalf("parseRevoke() = %+v, want %+v", ref, want)
		}

		ref, err = parseRevokeYes(revokeYesData(42, 7, pending))
		if err != nil {
			t.Fatalf("parseRevokeYes() error = %v", err)
		}
		if ref != want {
			t.Fatalf("parseRevokeYes() = %+v, want %+v", ref, want)
		}
	}
}

func TestShareCallbackRejectsBadData(t *testing.T) {
	for _, data := range []string{
		"v1:share_role:42",
		"v1:share_role:0:editor",
		"v1:share_role:42:owner",
		"v1:share_view:42:u",
		"v1:share_view:42:x:7",
		"v1:share_view:42:u:0",
		"v1:share_set:42:u:7",
		"v1:share_set:42:u:7:owner",
		"v1:share_revoke:42:u",
	} {
		if _, err := parseRefOrRole(data); err == nil {
			t.Fatalf("accepted invalid callback data %q", data)
		}
	}
}

func parseRefOrRole(data string) (any, error) {
	ref, role, err := parseSet(data)
	if err == nil {
		return struct {
			ref  shareRef
			role domain.Role
		}{ref, role}, nil
	}
	if ref, err := parseView(data); err == nil {
		return ref, nil
	}
	if ref, err := parseRevoke(data); err == nil {
		return ref, nil
	}
	if ref, err := parseRevokeYes(data); err == nil {
		return ref, nil
	}
	if listID, role, err := parseRole(data); err == nil {
		return struct {
			listID int64
			role   domain.Role
		}{listID, role}, nil
	}
	return nil, err
}