http

var RequestClass = &object.Class{
	Name: "Request",
	Methods: map[string]object.Object{
		"path_param": requestFieldGetter("path_params", "path_param", false, `path_param(name, default=None) - Get a path parameter captured from a route wildcard

Route patterns like "/api/users/{id}" capture the matching request path
segments. Returns the captured value, default, or None.

Parameters:
  name (string): Path parameter name
  default (any, optional): Value returned when the parameter is absent`),
		"query_param": requestFieldGetter("query", "query_param", false, `query_param(name, default=None) - Get a query parameter

Returns the first value of the query parameter, default, or None.

Parameters:
  name (string): Query parameter name
  default (any, optional): Value returned when the parameter is absent`),
		"header": requestFieldGetter("headers", "header", true, `header(name, default=None) - Get a request header

Header names are case-insensitive. Returns the header value, default, or None.

Parameters:
  name (string): Header name
  default (any, optional): Value returned when the header is absent`),
		"json": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.ExactArgs(args, 1); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("json() called on non-Request object")
				}

				body, err := instance.Field("body").AsString()
				if err != nil {
					return err
				}

				if body == "" {
					return &object.Null{}
				}

				return conversion.MustParseJSON(body)
			},
			HelpText: `json() - Parse request body as JSON

Returns the parsed JSON as a dict or list, or None if body is empty.`,
		},
	},
}

var State = struct {
	// HTTP routes, keyed "METHOD path"
	Routes          map[string]*RouteInfo
	Middleware      string
	NotFoundHandler string

	// WebSocket routes and connections
	WebSocketRoutes      map[string]*WebSocketRouteInfo
	WebSocketConnections map[string]*WebSocketServerConn
}{
	Routes:               make(map[string]*RouteInfo),
	WebSocketRoutes:      make(map[string]*WebSocketRouteInfo),
	WebSocketConnections: make(map[string]*WebSocketServerConn),
}

var WebSocketClientClass = &object.Class{
	Name: "WebSocketClient",
	Methods: map[string]object.Object{
		"connected": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.ExactArgs(args, 1); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("connected() called on non-WebSocketClient object")
				}

				conn := getWSConnFromInstance(instance)
				if conn == nil {
					return object.NewBoolean(false)
				}
				return object.NewBoolean(conn.IsConnected())
			},
			HelpText: `connected() - Check if the WebSocket connection is still open

Returns True if connected, False otherwise.`,
		},
		"receive": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.MinArgs(args, 1); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("receive() called on non-WebSocketClient object")
				}

				timeout := 30.0
				if t := kwargs.Get("timeout"); t != nil {
					if timeoutFloat, e := t.AsFloat(); e == nil {
						timeout = timeoutFloat
					}
				}

				conn := getWSConnFromInstance(instance)
				if conn == nil {
					return &object.Null{}
				}

				msgType, data, err := conn.ReadWithTimeout(time.Duration(timeout * float64(time.Second)))
				if err != nil || data == nil {
					return &object.Null{}
				}

				if msgType == websocket.TextMessage {
					return object.NewString(string(data))
				}

				elements := make([]object.Object, len(data))
				for i, b := range data {
					elements[i] = object.NewInteger(int64(b))
				}
				return &object.List{Elements: elements}
			},
			HelpText: `receive(timeout=30) - Receive a message from the WebSocket

Parameters:
  timeout (number, optional): Timeout in seconds (default: 30)

Returns:
  string for text messages, list of bytes for binary, or None on timeout/disconnect`,
		},
		"send": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.MinArgs(args, 2); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("send() called on non-WebSocketClient object")
				}

				msg := args[1]
				var data []byte

				if dict, ok := msg.(*object.Dict); ok {
					jsonData, jsonErr := json.Marshal(conversion.ToGo(dict))
					if jsonErr != nil {
						return errors.NewError("failed to encode JSON: %s", jsonErr.Error())
					}
					data = jsonData
				} else if str, ok := msg.(*object.String); ok {
					data = []byte(str.StringValue())
				} else {
					strVal, coerceErr := object.CoerceWireString(msg)
					if coerceErr != nil {
						return errors.NewError("message must be string or dict")
					}
					data = []byte(strVal)
				}

				conn := getWSConnFromInstance(instance)
				if conn == nil {
					return errors.NewError("connection closed")
				}

				if writeErr := conn.WriteMessage(websocket.TextMessage, data); writeErr != nil {
					return errors.NewError("send failed: %s", writeErr.Error())
				}
				return &object.Null{}
			},
			HelpText: `send(message) - Send a message to the WebSocket client

Parameters:
  message (string or dict): Message to send. Dicts are automatically JSON encoded.`,
		},
		"send_binary": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.MinArgs(args, 2); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("send_binary() called on non-WebSocketClient object")
				}

				list, ok := args[1].(*object.List)
				if !ok {
					return errors.NewError("send_binary requires a list of bytes")
				}

				data := make([]byte, len(list.Elements))
				for i, elem := range list.Elements {
					b, e := elem.AsInt()
					if e != nil || b < 0 || b > 255 {
						return errors.NewError("send_binary requires list of bytes (0-255)")
					}
					data[i] = byte(b)
				}

				conn := getWSConnFromInstance(instance)
				if conn == nil {
					return errors.NewError("connection closed")
				}

				if writeErr := conn.WriteMessage(websocket.BinaryMessage, data); writeErr != nil {
					return errors.NewError("send_binary failed: %s", writeErr.Error())
				}
				return &object.Null{}
			},
			HelpText: `send_binary(data) - Send binary data to the WebSocket client

Parameters:
  data (list): List of byte values (0-255)`,
		},
		"close": &object.Builtin{
			Fn: func(ctx context.Context, kwargs object.Kwargs, args ...object.Object) object.Object {
				if err := errors.ExactArgs(args, 1); err != nil {
					return err
				}
				instance, ok := args[0].(*object.Instance)
				if !ok {
					return errors.NewError("close() called on non-WebSocketClient object")
				}

				conn := getWSConnFromInstance(instance)
				if conn != nil {
					conn.Close()
				}
				return &object.Null{}
			},
			HelpText: `close() - Close the WebSocket connection`,
		},
	},
}