server

var (
	// GeneralSpxDefinitions are general spx definitions.
	GeneralSpxDefinitions = []SpxDefinition{
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("for_iterate")},
			Overview: "for v in arr {}",
			Detail:   "Iterate within given set",

			CompletionItemLabel:            "for",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "for ${1:v} in ${2:[]} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("for_iterate_with_index")},
			Overview: "for i, v in arr {}",
			Detail:   "Iterate with index within given set",

			CompletionItemLabel:            "for",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "for ${1:i}, ${2:v} in ${3:[]} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("for_loop_with_condition")},
			Overview: "for condition {}",
			Detail:   "Loop with condition",

			CompletionItemLabel:            "for",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "for ${1:true} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("for_loop_with_range")},
			Overview: "for i in start:end {}",
			Detail:   "Loop with range",

			CompletionItemLabel:            "for",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "for ${1:i} in ${2:1}:${3:5} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("if_statement")},
			Overview: "if condition {}",
			Detail:   "If statement",

			CompletionItemLabel:            "if",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "if ${1:true} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("if_else_statement")},
			Overview: "if condition {} else {}",
			Detail:   "If else statement",

			CompletionItemLabel:            "if",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "if ${1:true} {\n\t$2\n} else {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("var_declaration")},
			Overview: "var name type",
			Detail:   "Variable declaration, e.g., `var count int`",

			CompletionItemLabel:            "var",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "var ${1:name} $0",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
	}

	// FileScopeSpxDefinitions are spx definitions that are only available
	// in file scope.
	FileScopeSpxDefinitions = []SpxDefinition{
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("import_declaration")},
			Overview: "import \"package\"",
			Detail:   "Import package declaration, e.g., `import \"fmt\"`",

			CompletionItemLabel:            "import",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "import \"${1:package}\"$0",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
		{
			ID:       SpxDefinitionIdentifier{Name: ToPtr("func_declaration")},
			Overview: "func name(params) { ... }",
			Detail:   "Function declaration, e.g., `func add(a int, b int) int {}`",

			CompletionItemLabel:            "func",
			CompletionItemKind:             KeywordCompletion,
			CompletionItemInsertText:       "func ${1:name}(${2:params}) ${3:returnType} {\n\t$0\n}",
			CompletionItemInsertTextFormat: SnippetTextFormat,
		},
	}
)

var (
	// GetMathPkg returns the math package.
	GetMathPkg = sync.OnceValue(func() *types.Package {
		mathPkg, err := internal.Importer.Import("math")
		if err != nil {
			panic(fmt.Errorf("failed to import math package: %w", err))
		}
		return mathPkg
	})

	// GetMathPkgSpxDefinitions returns the spx definitions for the math package.
	GetMathPkgSpxDefinitions = sync.OnceValue(func() []SpxDefinition {
		mathPkg := GetMathPkg()
		mathPkgPath := xgoutil.PkgPath(mathPkg)
		mathPkgDoc, err := pkgdata.GetPkgDoc(mathPkgPath)
		if err != nil {
			panic(fmt.Errorf("failed to get math package doc: %w", err))
		}
		return GetSpxDefinitionsForPkg(mathPkg, mathPkgDoc)
	})
)

var (
	// GetSpxPkg returns the spx package.
	GetSpxPkg = sync.OnceValue(func() *types.Package {
		spxPkg, err := internal.Importer.Import(SpxPkgPath)
		if err != nil {
			panic(fmt.Errorf("failed to import spx package: %w", err))
		}
		return spxPkg
	})

	// GetSpxGameType returns the [spx.Game] type.
	GetSpxGameType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Game").Type().(*types.Named)
	})

	// GetSpxBackdropNameType returns the [spx.BackdropName] type.
	GetSpxBackdropNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("BackdropName").Type().(*types.Alias)
	})

	// GetSpxSpriteType returns the [spx.Sprite] type.
	GetSpxSpriteType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Sprite").Type().(*types.Named)
	})

	// GetSpxSpriteImplType returns the [spx.SpriteImpl] type.
	GetSpxSpriteImplType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("SpriteImpl").Type().(*types.Named)
	})

	// GetSpxSpriteNameType returns the [spx.SpriteName] type.
	GetSpxSpriteNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("SpriteName").Type().(*types.Alias)
	})

	// GetSpxSpriteCostumeNameType returns the [spx.SpriteCostumeName] type.
	GetSpxSpriteCostumeNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("SpriteCostumeName").Type().(*types.Alias)
	})

	// GetSpxSpriteAnimationNameType returns the [spx.SpriteAnimationName] type.
	GetSpxSpriteAnimationNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("SpriteAnimationName").Type().(*types.Alias)
	})

	// GetSpxSoundNameType returns the [spx.SoundName] type.
	GetSpxSoundNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("SoundName").Type().(*types.Alias)
	})

	// GetSpxWidgetNameType returns the [spx.WidgetName] type.
	GetSpxWidgetNameType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("WidgetName").Type().(*types.Alias)
	})

	// GetSpxDirectionType returns the [spx.Direction] type.
	GetSpxDirectionType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Direction").Type().(*types.Alias)
	})

	// GetSpxLayerActionType returns the [spx.LayerAction] type.
	GetSpxLayerActionType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("layerAction").Type().(*types.Named)
	})

	// GetSpxDirActionType returns the [spx.DirLayer] type.
	GetSpxDirActionType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("dirAction").Type().(*types.Named)
	})

	// GetSpxEffectKindType returns the [spx.EffectKind] type.
	GetSpxEffectKindType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("EffectKind").Type().(*types.Named)
	})

	// GetSpxKeyType returns the [spx.Key] type.
	GetSpxKeyType = sync.OnceValue(func() *types.Alias {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Key").Type().(*types.Alias)
	})

	// GetSpxSpecialObjType returns the [spx.SpecialObj] type.
	GetSpxSpecialObjType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Edge").Type().(*types.Named)
	})

	// GetSpxRotationStyleType returns the [spx.RotationStyle] type.
	GetSpxRotationStyleType = sync.OnceValue(func() *types.Named {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("RotationStyle").Type().(*types.Named)
	})

	// GetSpxPkgDefinitions returns the spx definitions for the spx package.
	GetSpxPkgDefinitions = sync.OnceValue(func() []SpxDefinition {
		spxPkg := GetSpxPkg()
		spxPkgPath := xgoutil.PkgPath(spxPkg)
		spxPkgDoc, err := pkgdata.GetPkgDoc(spxPkgPath)
		if err != nil {
			panic(fmt.Errorf("failed to get spx package doc: %w", err))
		}
		return GetSpxDefinitionsForPkg(spxPkg, spxPkgDoc)
	})

	// GetSpxHSBFunc returns the [spx.HSB] type.
	GetSpxHSBFunc = sync.OnceValue(func() *types.Func {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("HSB").(*types.Func)
	})

	// GetSpxHSBAFunc returns the [spx.HSBA] type.
	GetSpxHSBAFunc = sync.OnceValue(func() *types.Func {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("HSBA").(*types.Func)
	})

	// GetSpxGoptGameRunFunc returns the [spx.Gopt_Game_Run] type.
	GetSpxGoptGameRunFunc = sync.OnceValue(func() *types.Func {
		spxPkg := GetSpxPkg()
		return spxPkg.Scope().Lookup("Gopt_Game_Run").(*types.Func)
	})
)

var GetBuiltinSpxDefinitions = sync.OnceValue(func() []SpxDefinition {
	names := types.Universe.Names()
	defs := make([]SpxDefinition, 0, len(names)+len(xgoBuiltinAliases))
	for _, name := range names {
		if _, ok := xgoBuiltinAliases[name]; ok {
			continue
		}
		if obj := types.Universe.Lookup(name); obj != nil && obj.Pkg() == nil {
			defs = append(defs, GetSpxDefinitionForBuiltinObj(obj))
		}
	}
	for alias := range xgoBuiltinAliases {
		def, err := getSpxDefinitionForXGoBuiltinAlias(alias)
		if err != nil {
			panic(fmt.Errorf("failed to get spx definition for xgo builtin alias %q: %w", alias, err))
		}
		defs = append(defs, def)
	}
	return slices.Clip(defs)
})