package github

import (

"context"

"errors"

"fmt"

"reflect"

"sync"

"github.com/shurcooL/githubv4"

)

const batchMutationWireChunkSize = 20

type batchMutationKind int

const (

batchMutationUpdate batchMutationKind = iota

batchMutationClear

)

func (k batchMutationKind) fieldName() string {

if k == batchMutationClear {

return "clearProjectV2ItemFieldValue"

}

return "updateProjectV2ItemFieldValue"

}

type projectV2ItemMutationResult struct {

ProjectV2Item struct {

ID string

FullDatabaseID string `graphql:"fullDatabaseId"`

} `graphql:"projectV2Item"`

}

type reflectedMutationTypeKey struct {

kind batchMutationKind

size int

}

var reflectedMutationTypeCache sync.Map

// Reflected types are cached only by operation and chunk size to bound

// reflect.StructOf's runtime cache; positional names and tags keep request data

// out of type identities. The pinned Client.Mutate binds its third argument to

// $input, so item0 uses $input and later aliases use $input1, $input2, ...

// supplied through the variables map.

func buildAliasedMutationType(kind batchMutationKind, size int) reflect.Type {

key := reflectedMutationTypeKey{kind: kind, size: size}

if cached, ok := reflectedMutationTypeCache.Load(key); ok {

return cached.(reflect.Type)

}

resultType := reflect.TypeFor[projectV2ItemMutationResult]()

fields := make([]reflect.StructField, size)

for i := range size {

varName := "input"

if i > 0 {

varName = fmt.Sprintf("input%d", i)

}

fields[i] = reflect.StructField{

Name: fmt.Sprintf("Item%d", i),

Type: resultType,

Tag: reflect.StructTag(fmt.Sprintf(`graphql:"item%d: %s(input: $%s)"`, i, kind.fieldName(), varName)),

}

}

t := reflect.StructOf(fields)

actual, _ := reflectedMutationTypeCache.LoadOrStore(key, t)

return actual.(reflect.Type)

}

type mutationAliasOutcome struct {

// Populated confirms this alias returned a project item, even when the

// response also contains GraphQL errors.

Populated bool

NodeID string

FullDatabaseID string

}

// The pinned client decodes partial data before returning GraphQL errors but

// discards errors[].path. Populated aliases confirm writes; unpopulated aliases

// remain unknown and must not be retried individually.

func executeAliasedMutation(ctx context.Context, gqlClient *githubv4.Client, kind batchMutationKind, inputs []githubv4.Input) ([]mutationAliasOutcome, error) {

if len(inputs) == 0 {

return nil, nil

}

if len(inputs) > batchMutationWireChunkSize {

return nil, fmt.Errorf("internal error: chunk of %d exceeds wire chunk size %d", len(inputs), batchMutationWireChunkSize)

}

mutationType := buildAliasedMutationType(kind, len(inputs))

mutationPtr := reflect.New(mutationType)

var variables map[string]any

if len(inputs) > 1 {

variables = make(map[string]any, len(inputs)-1)

for i := 1; i < len(inputs); i++ {

variables[fmt.Sprintf("input%d", i)] = inputs[i]

}

}

mutateErr := gqlClient.Mutate(ctx, mutationPtr.Interface(), inputs[0], variables)

outcomes := make([]mutationAliasOutcome, len(inputs))

elem := mutationPtr.Elem()

for i := range inputs {

result, ok := elem.Field(i).Interface().(projectV2ItemMutationResult)

if !ok || result.ProjectV2Item.ID == "" {

continue

}

outcomes[i] = mutationAliasOutcome{

Populated: true,

NodeID: result.ProjectV2Item.ID,

FullDatabaseID: result.ProjectV2Item.FullDatabaseID,

}

}

return outcomes, mutateErr

}

// The pinned client's GraphQL response error type is unexported; transport and

// decoding failures must remain distinguishable.

func isGraphQLResponseError(err error) bool {

for err != nil {

errType := reflect.TypeOf(err)

if errType.PkgPath() == "github.com/shurcooL/graphql" && errType.Name() == "errors" {

return true

}

err = errors.Unwrap(err)

}

return false

}