package runtime

import (
	"encoding/json"
	"fmt"

	"git.novox.be/novox/mesh-sdk/go/buscalls"
)

// BusState answers a bundle's calls on its module's bus state in the new form (mesh-sdk buscalls; novox/hq ADR 0595
// §9, design 25 § 12.5; issue 1966): each as the module whose bundle asks, never a module the request names, so a
// bundle reaches its own module's bindings alone.
func (b *moduleBus) BusState(method string, params json.RawMessage) (json.RawMessage, error) {
	conn := b.all.conn
	var answer any
	var err error
	switch method {
	case buscalls.ObjectsPut:
		var r buscalls.ObjectsPutRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.ObjectsPut(b.module, r)
		}
	case buscalls.ObjectsGet:
		var r buscalls.ObjectsNameRequest
		if err = decode(method, params, &r); err == nil {
			var got *buscalls.ObjectData
			if got, err = conn.ObjectsGet(b.module, r); err == nil && got == nil {
				return json.RawMessage("null"), nil
			}
			answer = got
		}
	case buscalls.ObjectsDelete:
		var r buscalls.ObjectsNameRequest
		if err = decode(method, params, &r); err == nil {
			err = conn.ObjectsDelete(b.module, r)
			answer = buscalls.Done{}
		}
	case buscalls.ObjectsList:
		var r buscalls.ObjectsRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.ObjectsList(b.module, r)
		}
	case buscalls.ObjectsInfo:
		var r buscalls.ObjectsRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.ObjectsInfo(b.module, r)
		}
	case buscalls.StreamRead:
		var r buscalls.StreamReadRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.StreamRead(b.module, r)
		}
	case buscalls.StreamFill:
		var r buscalls.StreamRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.StreamFill(b.module, r)
		}
	case buscalls.WorkQueueSize:
		var r buscalls.WorkQueueRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.WorkQueueSize(b.module, r)
		}
	case buscalls.WorkQueueDead:
		var r buscalls.WorkQueueDeadRequest
		if err = decode(method, params, &r); err == nil {
			answer, err = conn.WorkQueueDead(b.module, r)
		}
	default:
		return nil, fmt.Errorf("the runtime answers no %s", method)
	}
	if err != nil {
		return nil, err
	}
	return json.Marshal(answer)
}

// BusStateWatch hands a bundle each change of its objects or its ledger, the current ones first.
func (b *moduleBus) BusStateWatch(method string, params json.RawMessage, deliver func(json.RawMessage) error) (func(), error) {
	switch method {
	case buscalls.ObjectsWatch:
		var r buscalls.ObjectsWatchRequest
		if err := decode(method, params, &r); err != nil {
			return nil, err
		}
		return b.all.conn.ObjectsWatch(b.module, r, func(change buscalls.ObjectsChange) error {
			raw, err := json.Marshal(change)
			if err != nil {
				return err
			}
			return deliver(raw)
		})
	}
	return nil, fmt.Errorf("the runtime answers no %s", method)
}

// decode reads a bus-state call's request.
func decode(method string, params json.RawMessage, into any) error {
	if err := json.Unmarshal(params, into); err != nil {
		return fmt.Errorf("%s's request is not of its shape (mesh-sdk buscalls): %w", method, err)
	}
	return nil
}