core

type AssetsFetcher interface {
	Fetch(req *WorkerRequest) (*WorkerResponse, error)
}

type BinaryTransferer interface {
	// ReadBinaryFromJS reads binary data from a JS buffer stored at the
	// given global variable name and returns it as Go bytes.
	ReadBinaryFromJS(globalName string) ([]byte, error)

	// WriteBinaryToJS writes Go bytes into a JS ArrayBuffer at the given
	// global variable name.
	WriteBinaryToJS(globalName string, data []byte) error

	// BinaryMode returns the JS buffer type to use for binary transfer:
	// "sab" for SharedArrayBuffer (V8), "ab" for ArrayBuffer (QuickJS).
	BinaryMode() string
}

type CacheEntry struct {
	Status    int
	Headers   string
	Body      []byte
	ExpiresAt *time.Time
}

type CacheStore interface {
	Match(cacheName, url string) (*CacheEntry, error)
	Put(cacheName, url string, status int, headers string, body []byte, ttl *int) error
	Delete(cacheName, url string) (bool, error)
}

type CryptoKeyEntry struct {
	Data        []byte // Raw key bytes (symmetric keys)
	HashAlgo    string // Associated hash algorithm
	AlgoName    string // Algorithm name (HMAC, AES-GCM, ECDSA, AES-CBC)
	KeyType     string // "secret", "public", "private"
	NamedCurve  string // For EC keys: "P-256", "P-384"
	EcKey       any    // *ecdsa.PrivateKey or *ecdsa.PublicKey
	Extractable bool   // WebCrypto extractable flag
}

type D1ExecResult struct {
	Columns []string        `json:"columns"`
	Rows    [][]interface{} `json:"rows"`
	Meta    D1Meta          `json:"meta"`
}

type D1Meta struct {
	ChangedDB   bool  `json:"changed_db"`
	Changes     int64 `json:"changes"`
	LastRowID   int64 `json:"last_row_id"`
	RowsRead    int   `json:"rows_read"`
	RowsWritten int   `json:"rows_written"`
}

type D1Store interface {
	Exec(sql string, bindings []interface{}) (*D1ExecResult, error)
	Close() error
}

type DurableObjectStore interface {
	Get(namespace, objectID, key string) (string, error)
	GetMulti(namespace, objectID string, keys []string) (map[string]string, error)
	Put(namespace, objectID, key, valueJSON string) error
	PutMulti(namespace, objectID string, entries map[string]string) error
	Delete(namespace, objectID, key string) error
	DeleteMulti(namespace, objectID string, keys []string) (int, error)
	DeleteAll(namespace, objectID string) error
	List(namespace, objectID, prefix string, limit int, reverse bool) ([]KVPair, error)
}

type EngineBackend interface {
	Execute(siteID, deployKey string, env *Env, req *WorkerRequest) *WorkerResult
	ExecuteScheduled(siteID, deployKey string, env *Env, cron string) *WorkerResult
	ExecuteTail(siteID, deployKey string, env *Env, events []TailEvent) *WorkerResult
	ExecuteFunction(siteID, deployKey string, env *Env, fnName string, args ...any) *WorkerResult
	EnsureSource(siteID, deployKey string) error
	CompileAndCache(siteID, deployKey string, source string) ([]byte, error)
	InvalidatePool(siteID, deployKey string)
	Shutdown()
	SetDispatcher(d WorkerDispatcher)
	MaxResponseBytes() int
}

type EngineConfig struct {
	PoolSize         int // number of JS runtime instances per site pool
	MemoryLimitMB    int // per-runtime memory limit
	ExecutionTimeout int // milliseconds before worker is terminated
	MaxFetchRequests int // max outbound fetches per request
	FetchTimeoutSec  int // per-fetch timeout in seconds
	MaxResponseBytes int // max response body size
	MaxScriptSizeKB  int // max bundled script size
}

type Env struct {
	Vars    map[string]string
	Secrets map[string]string

	// Opt-in bindings — nil means disabled
	KV              map[string]KVStore
	Cache           CacheStore
	Storage         map[string]R2Store
	Queues          map[string]QueueSender
	D1Bindings      map[string]string  // binding name -> database ID
	D1              map[string]D1Store // binding name -> D1Store (opened by engine)
	DurableObjects  map[string]DurableObjectStore
	ServiceBindings map[string]ServiceBindingConfig

	// CustomBindings allows downstream users to add arbitrary bindings
	// to the env object. Each function is called per-request and its
	// returned value is set on env under the map key name.
	CustomBindings map[string]EnvBindingFunc

	// D1 configuration
	D1DataDir string

	// Runtime references
	Assets     AssetsFetcher
	Dispatcher WorkerDispatcher // set by Engine before execution
	SiteID     string           // site isolation key
	// contains filtered or unexported fields
}

type EnvBindingFunc func(rt JSRuntime) (any, error)

type JSRuntime interface {
	// Eval evaluates JavaScript source and discards the result.
	Eval(js string) error

	// EvalString evaluates JavaScript and returns the result as a Go string.
	EvalString(js string) (string, error)

	// EvalBool evaluates JavaScript and returns the result as a Go bool.
	EvalBool(js string) (bool, error)

	// EvalInt evaluates JavaScript and returns the result as a Go int.
	EvalInt(js string) (int, error)

	// RegisterFunc registers a Go function as a global JavaScript function.
	// The function's Go types are automatically marshaled to/from JS types.
	// On error return, the JS wrapper throws a TypeError instead of
	// returning an array.
	RegisterFunc(name string, fn any) error

	// SetGlobal sets a global variable on the JS context. Basic Go types
	// (string, int, float64, bool) are auto-converted to JS types.
	SetGlobal(name string, value any) error

	// RunMicrotasks pumps the microtask queue (Promise callbacks, etc.).
	// V8: PerformMicrotaskCheckpoint, QuickJS: ExecutePendingJob loop.
	RunMicrotasks()
}

type KVListResult struct {
	Keys         []map[string]interface{}
	ListComplete bool
	Cursor       string // base64-encoded offset, empty when list is complete
}

type KVPair struct {
	Key   string
	Value string
}

type KVStore interface {
	Get(key string) (*string, error)
	GetWithMetadata(key string) (*KVValueWithMetadata, error)
	Put(key, value string, metadata *string, ttl *int) error
	Delete(key string) error
	List(prefix string, limit int, cursor string) (*KVListResult, error)
}

type KVValueWithMetadata struct {
	Value    string
	Metadata *string
}

type LogEntry struct {
	Level   string    `json:"level"`
	Message string    `json:"message"`
	Time    time.Time `json:"time"`
}

type QueueMessageInput struct {
	Body        string
	ContentType string
}

type QueueSender interface {
	Send(body, contentType string) (string, error)
	SendBatch(messages []QueueMessageInput) ([]string, error)
}

type R2ListOptions struct {
	Prefix    string
	Delimiter string
	Cursor    string
	Limit     int
}

type R2ListResult struct {
	Objects           []R2Object
	Truncated         bool
	Cursor            string
	DelimitedPrefixes []string
}

type R2Object struct {
	Key            string
	Size           int64
	ContentType    string
	ETag           string
	LastModified   time.Time
	CustomMetadata map[string]string
}

type R2PutOptions struct {
	ContentType    string
	CustomMetadata map[string]string
}

type R2Store interface {
	Get(key string) ([]byte, *R2Object, error)
	Put(key string, data []byte, opts R2PutOptions) (*R2Object, error)
	Delete(keys []string) error
	Head(key string) (*R2Object, error)
	List(opts R2ListOptions) (*R2ListResult, error)
	PresignedGetURL(key string, expiry time.Duration) (string, error)
	PublicURL(key string) (string, error)
}

type RequestState struct {
	Logs       []LogEntry
	FetchCount int
	MaxFetches int
	Env        *Env
	CryptoKeys map[int]*CryptoKeyEntry
	NextKeyID  int

	// WebSocket bridge state (set when status 101 response is returned).
	// Typed as any to avoid importing coder/websocket in core.
	WsConn   any // *websocket.Conn
	WsMu     sync.Mutex
	WsClosed bool

	// DigestStream state: per-request hash instances keyed by stream ID.
	DigestStreams map[string]hash.Hash
	NextDigestID  int64

	// TCP socket state: per-request TCP connections keyed by socket ID.
	TcpSockets      map[string]net.Conn
	NextTCPSocketID int64

	// In-flight fetch cancellation: maps fetchID -> cancel function.
	FetchCancels map[string]context.CancelFunc
	NextFetchID  int64
	// contains filtered or unexported fields
}

type ServiceBindingConfig struct {
	TargetSiteID    string
	TargetDeployKey string
}

type SourceLoader interface {
	GetWorkerScript(siteID, deployKey string) (string, error)
}

type TailEvent struct {
	ScriptName string     `json:"scriptName"`
	Logs       []LogEntry `json:"logs"`
	Exceptions []string   `json:"exceptions"`
	Outcome    string     `json:"outcome"`
	Timestamp  time.Time  `json:"timestamp"`
}

type WebSocketBridger interface {
	Bridge(ctx context.Context, httpConn *websocket.Conn)
}

type WorkerDispatcher interface {
	Execute(siteID, deployKey string, env *Env, req *WorkerRequest) *WorkerResult
}

type WorkerRequest struct {
	Method  string
	URL     string
	Headers map[string]string
	Body    []byte
}

type WorkerResponse struct {
	StatusCode   int
	Headers      map[string]string
	Body         []byte
	HasWebSocket bool // true when status is 101 and webSocket was set
}

type WorkerResult struct {
	Response  *WorkerResponse
	Logs      []LogEntry
	Error     error
	Duration  time.Duration
	WebSocket WebSocketBridger // engine-specific WebSocket handler
	Data      string           // JSON-serialized return value from ExecuteFunction
}