const (
	MessageKindJSON string = "json"
	MessageKindBlob string = "blob"
)

var ErrShutdown = fmt.Errorf("dispatcher is shutting down")

type Binary struct {
	// The name of the binary.
	// For 	quickjs, this must match the instance import name, "javy_quickjs_provider_v2".
	// For the main module, we only use this for caching.
	Name string

	// THe wasm binary.
	Data []byte
}

type CommonImageProcessingParams struct {
	Width  int `json:"width,omitempty"`
	Height int `json:"height,omitempty"`
	Stride int `json:"stride,omitempty"`

	// For animated images.
	FrameDurations []int `json:"frameDurations,omitempty"`
	LoopCount      int   `json:"loopCount,omitempty"`
}

type CompileModuleContext struct {
	Opts    Options
	Runtime wazero.Runtime
}

type CompiledModule struct {
	// Runtime (e.g. QuickJS) may be nil if not needed (e.g. embedded in Module).
	Runtime wazero.CompiledModule

	// If Runtime is not nil, this should be the name of the instance.
	RuntimeName string

	// The main module to instantiate.
	// This will be insantiated multiple times in a pool,
	// so it does not need a name.
	Module wazero.CompiledModule
}

type DestinationProvider interface {
	GetDestination() io.Writer
}

type Dispatcher[Q, R any] interface {
	Execute(ctx context.Context, q Message[Q]) (Message[R], error)
	Close() error
}

type Dispatchers struct {
	// contains filtered or unexported fields
}

type Header struct {
	// Major version of the protocol.
	Version uint16 `json:"version"`

	// Unique ID for the request.
	// Note that this only needs to be unique within the current request set time window.
	ID uint32 `json:"id"`

	// Command is the command to execute.
	Command string `json:"command"`

	// RequestKinds is a list of kinds in this RPC request,
	// e.g. {"json", "blob"}, or {"json"}.
	RequestKinds []string `json:"requestKinds"`
	// ResponseKinds is a list of kinds expected in the response,
	// e.g. {"json", "blob"}, or {"json"}.
	ResponseKinds []string `json:"responseKinds"`

	// Set in the response if there was an error.
	Err string `json:"err"`

	// Warnings is a list of warnings that may be returned in the response.
	Warnings []string `json:"warnings,omitempty"`
}

type KatexInput struct {
	Expression string       `json:"expression"`
	Options    KatexOptions `json:"options"`
}

type KatexOptions struct {
	// html, mathml (default), htmlAndMathml
	Output string `json:"output"`

	// If true, display math in display mode, false in inline mode.
	DisplayMode bool `json:"displayMode"`

	// Render \tags on the left side instead of the right.
	Leqno bool `json:"leqno"`

	// If true,  render flush left with a 2em left margin.
	Fleqn bool `json:"fleqn"`

	// The color used for typesetting errors.
	// A color string given in the format "#XXX" or "#XXXXXX"
	ErrorColor string `json:"errorColor"`

	// A collection of custom macros.
	Macros map[string]string `json:"macros,omitempty"`

	// Specifies a minimum thickness, in ems, for fraction lines.
	MinRuleThickness float64 `json:"minRuleThickness"`

	// If true, KaTeX will throw a ParseError when it encounters an unsupported command.
	ThrowOnError bool `json:"throwOnError"`

	// Controls how KaTeX handles LaTeX features that offer convenience but
	// aren't officially supported, one of error (default), ignore, or warn.
	//
	//  - error: Throws an error when convenient, unsupported LaTeX features
	//    are encountered.
	//  - ignore: Allows convenient, unsupported LaTeX features without any
	//    feedback.
	//  - warn: Emits a warning when convenient, unsupported LaTeX features are
	//    encountered.
	//
	// The "newLineInDisplayMode" error code, which flags the use of \\
	// or \newline in display mode outside an array or tabular environment, is
	// intentionally designed not to throw an error, despite this behavior
	// being questionable.
	Strict string `json:"strict"`
}

type KatexOutput struct {
	Output string `json:"output"`
}

type Message[T any] struct {
	Header Header `json:"header"`
	Data   T      `json:"data"`
}

type Options struct {
	Ctx context.Context

	Infof func(format string, v ...any)

	Warnf func(format string, v ...any)

	// E.g. quickjs wasm. May be omitted if not needed.
	Runtime Binary

	// The main module to instantiate.
	Main Binary

	CompilationCacheDir string
	PoolSize            int

	// Memory limit in MiB.
	Memory int
}

type ProtocolType int

const (
	ProtocolJSON          ProtocolType = iota + 1
	ProtocolJSONAndBinary              = iota
)

type SourceProvider interface {
	GetSource() hugio.SizeReader
}

type WEBP struct {
	image.Image // The first frame.
	// contains filtered or unexported fields
}

type WebpCodec struct {
	// contains filtered or unexported fields
}

type WebpInput struct {
	Source      hugio.SizeReader `json:"-"`       // Will be sent in a separate stream.
	Destination io.Writer        `json:"-"`       // Will be used to write the result to.
	Options     map[string]any   `json:"options"` // Config options.
	Params      map[string]any   `json:"params"`  // Command params (width, height, etc.).
}

type WebpOutput struct {
	Params CommonImageProcessingParams `json:"params"`
}