// Generated by `wit-bindgen` 0.57.1. DO NOT EDIT!
//
// This code was generated from the following packages:
//     pumpkin:plugin@0.1.0

package pumpkin_plugin_server

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_common"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_player"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_text"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_world"
	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
	witTypes "go.bytecodealliance.org/pkg/wit/types"
	"runtime"
	"unsafe"
)

type Player = pumpkin_plugin_player.Player
type GameMode = pumpkin_plugin_common.GameMode
type World = pumpkin_plugin_world.World
type TextComponent = pumpkin_plugin_text.TextComponent

const (
	// Hostile mobs do not spawn. Players regain health automatically.
	DifficultyPeaceful uint8 = 0
	// Hostile mobs deal less damage.
	DifficultyEasy uint8 = 1
	// Standard Minecraft difficulty.
	DifficultyNormal uint8 = 2
	// Hostile mobs deal more damage.
	DifficultyHard uint8 = 3
)

// Represents the difficulty setting of a Minecraft server.
type Difficulty = uint8

const (
	DimensionOverworld uint8 = 0
	DimensionNether    uint8 = 1
	DimensionEnd       uint8 = 2
)

// Represents the three main Minecraft dimensions.
type Dimension = uint8

const (
	CommandSenderConsole uint8 = 0
	CommandSenderPlayer  uint8 = 1
)

type CommandSender struct {
	tag   uint8
	value any
}

func (self CommandSender) Tag() uint8 {
	return self.tag
}

func (self CommandSender) Player() *pumpkin_plugin_player.Player {
	if self.tag != CommandSenderPlayer {
		panic("tag mismatch")
	}
	return self.value.(*pumpkin_plugin_player.Player)
}

func MakeCommandSenderConsole() CommandSender {
	return CommandSender{CommandSenderConsole, nil}
}
func MakeCommandSenderPlayer(value *pumpkin_plugin_player.Player) CommandSender {
	return CommandSender{CommandSenderPlayer, value}
}

//go:wasmimport pumpkin:plugin/server@0.1.0 [resource-drop]server
func resourceDropServer(handle int32)

// Represents the global server instance.
type Server struct {
	handle *witRuntime.Handle
}

func (self *Server) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *Server) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *Server) Handle() int32 {
	return self.handle.Use()
}

func (self *Server) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropServer(handle)
	}
}

func ServerFromOwnHandle(handleValue int32) *Server {
	handle := witRuntime.MakeHandle(handleValue)
	value := &Server{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropServer(handleValue)
		}
	}, 0)
	return value
}

func ServerFromBorrowHandle(handleValue int32) *Server {
	handle := witRuntime.MakeHandle(handleValue)
	return &Server{handle}
}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-difficulty
func wasm_import_method_server_get_difficulty(arg0 int32) int32

func (self *Server) GetDifficulty() Difficulty {

	result := wasm_import_method_server_get_difficulty((self).Handle())
	return uint8(result)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-player-count
func wasm_import_method_server_get_player_count(arg0 int32) int32

func (self *Server) GetPlayerCount() uint32 {

	result := wasm_import_method_server_get_player_count((self).Handle())
	return uint32(result)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-mspt
func wasm_import_method_server_get_mspt(arg0 int32) float64

func (self *Server) GetMspt() float64 {

	result := wasm_import_method_server_get_mspt((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-tps
func wasm_import_method_server_get_tps(arg0 int32) float64

func (self *Server) GetTps() float64 {

	result := wasm_import_method_server_get_tps((self).Handle())
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-all-players
func wasm_import_method_server_get_all_players(arg0 int32, arg1 uintptr)

func (self *Server) GetAllPlayers() []*pumpkin_plugin_player.Player {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_server_get_all_players((self).Handle(), returnArea)
	result := make([]*pumpkin_plugin_player.Player, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*4)

		result = append(result, pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
	}

	result0 := result
	return result0

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-player-by-name
func wasm_import_method_server_get_player_by_name(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)

func (self *Server) GetPlayerByName(name string) witTypes.Option[*pumpkin_plugin_player.Player] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
	utf8 := unsafe.Pointer(unsafe.StringData(name))
	pinner.Pin(utf8)
	wasm_import_method_server_get_player_by_name((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
	var option witTypes.Option[*pumpkin_plugin_player.Player]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[*pumpkin_plugin_player.Player]()
	case 1:

		option = witTypes.Some[*pumpkin_plugin_player.Player](pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-player-by-uuid
func wasm_import_method_server_get_player_by_uuid(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)

func (self *Server) GetPlayerByUuid(id string) witTypes.Option[*pumpkin_plugin_player.Player] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
	utf8 := unsafe.Pointer(unsafe.StringData(id))
	pinner.Pin(utf8)
	wasm_import_method_server_get_player_by_uuid((self).Handle(), uintptr(utf8), uint32(len(id)), returnArea)
	var option witTypes.Option[*pumpkin_plugin_player.Player]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[*pumpkin_plugin_player.Player]()
	case 1:

		option = witTypes.Some[*pumpkin_plugin_player.Player](pumpkin_plugin_player.PlayerFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-all-worlds
func wasm_import_method_server_get_all_worlds(arg0 int32, arg1 uintptr)

func (self *Server) GetAllWorlds() []*pumpkin_plugin_world.World {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_server_get_all_worlds((self).Handle(), returnArea)
	result := make([]*pumpkin_plugin_world.World, 0, *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
	for index := 0; index < int(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))); index++ {
		base := unsafe.Add(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0)))), index*4)

		result = append(result, pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(base), 0))))))
	}

	result0 := result
	return result0

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-world-by-name
func wasm_import_method_server_get_world_by_name(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr)

func (self *Server) GetWorldByName(name string) witTypes.Option[*pumpkin_plugin_world.World] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, 8, 4))
	utf8 := unsafe.Pointer(unsafe.StringData(name))
	pinner.Pin(utf8)
	wasm_import_method_server_get_world_by_name((self).Handle(), uintptr(utf8), uint32(len(name)), returnArea)
	var option witTypes.Option[*pumpkin_plugin_world.World]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		option = witTypes.None[*pumpkin_plugin_world.World]()
	case 1:

		option = witTypes.Some[*pumpkin_plugin_world.World](pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(*(*int32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))))
	default:
		panic("unreachable")
	}
	result := option
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.execute-command
func wasm_import_method_server_execute_command(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32, arg4 int32)

func (self *Server) ExecuteCommand(command string, sender CommandSender) {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(command))
	pinner.Pin(utf8)
	var variant int32
	var variant0 int32
	switch sender.Tag() {
	case CommandSenderConsole:

		variant = int32(0)
		variant0 = 0

	case CommandSenderPlayer:
		payload := sender.Player()

		variant = int32(1)
		variant0 = (payload).TakeHandle()

	default:
		panic("unreachable")
	}
	wasm_import_method_server_execute_command((self).Handle(), uintptr(utf8), uint32(len(command)), variant, variant0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.create-world
func wasm_import_method_server_create_world(arg0 int32, arg1 uintptr, arg2 uint32, arg3 int32) int32

func (self *Server) CreateWorld(name string, dimension Dimension) *pumpkin_plugin_world.World {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(name))
	pinner.Pin(utf8)
	result := wasm_import_method_server_create_world((self).Handle(), uintptr(utf8), uint32(len(name)), int32(dimension))
	return pumpkin_plugin_world.WorldFromOwnHandle(int32(uintptr(result)))

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.broadcast
func wasm_import_method_server_broadcast(arg0 int32, arg1 uintptr, arg2 uint32)

func (self *Server) Broadcast(message string) {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(message))
	pinner.Pin(utf8)
	wasm_import_method_server_broadcast((self).Handle(), uintptr(utf8), uint32(len(message)))

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.broadcast-tab-list-header-footer
func wasm_import_method_server_broadcast_tab_list_header_footer(arg0 int32, arg1 int32, arg2 int32)

func (self *Server) BroadcastTabListHeaderFooter(header *pumpkin_plugin_text.TextComponent, footer *pumpkin_plugin_text.TextComponent) {

	wasm_import_method_server_broadcast_tab_list_header_footer((self).Handle(), (header).TakeHandle(), (footer).TakeHandle())

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-max-players
func wasm_import_method_server_get_max_players(arg0 int32) int32

func (self *Server) GetMaxPlayers() uint32 {

	result := wasm_import_method_server_get_max_players((self).Handle())
	return uint32(result)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.is-hardcore
func wasm_import_method_server_is_hardcore(arg0 int32) int32

func (self *Server) IsHardcore() bool {

	result := wasm_import_method_server_is_hardcore((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.is-online-mode
func wasm_import_method_server_is_online_mode(arg0 int32) int32

func (self *Server) IsOnlineMode() bool {

	result := wasm_import_method_server_is_online_mode((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-motd
func wasm_import_method_server_get_motd(arg0 int32, arg1 uintptr)

func (self *Server) GetMotd() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_server_get_motd((self).Handle(), returnArea)
	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
	result := value
	return result

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.has-whitelist
func wasm_import_method_server_has_whitelist(arg0 int32) int32

func (self *Server) HasWhitelist() bool {

	result := wasm_import_method_server_has_whitelist((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-allow-nether
func wasm_import_method_server_get_allow_nether(arg0 int32) int32

func (self *Server) GetAllowNether() bool {

	result := wasm_import_method_server_get_allow_nether((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-allow-end
func wasm_import_method_server_get_allow_end(arg0 int32) int32

func (self *Server) GetAllowEnd() bool {

	result := wasm_import_method_server_get_allow_end((self).Handle())
	return (result != 0)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-view-distance
func wasm_import_method_server_get_view_distance(arg0 int32) int32

func (self *Server) GetViewDistance() uint8 {

	result := wasm_import_method_server_get_view_distance((self).Handle())
	return uint8(result)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-simulation-distance
func wasm_import_method_server_get_simulation_distance(arg0 int32) int32

func (self *Server) GetSimulationDistance() uint8 {

	result := wasm_import_method_server_get_simulation_distance((self).Handle())
	return uint8(result)

}

//go:wasmimport pumpkin:plugin/server@0.1.0 [method]server.get-default-gamemode
func wasm_import_method_server_get_default_gamemode(arg0 int32) int32

func (self *Server) GetDefaultGamemode() pumpkin_plugin_common.GameMode {

	result := wasm_import_method_server_get_default_gamemode((self).Handle())
	return uint8(result)

}