package main

import (
	"bytes"
	"fmt"
)

type GrainHandler struct {
	*CartServer
	pool *GrainLocalPool
}

func (h *GrainHandler) GetState(id CartId, reply *Grain) error {
	grain, err := h.pool.GetGrain(id)
	if err != nil {
		return err
	}
	*reply = grain
	return nil
}

func NewGrainHandler(pool *GrainLocalPool, listen string) (*GrainHandler, error) {
	server, err := CartListen(listen)
	handler := &GrainHandler{
		CartServer: server,
		pool:       pool,
	}
	server.HandleCall(RemoteHandleMessage, handler.RemoteHandleMessageHandler)
	server.HandleCall(RemoteGetState, handler.RemoteGetStateHandler)
	return handler, err
}

func (h *GrainHandler) RemoteHandleMessageHandler(id CartId, data []byte) (uint16, []byte, error) {
	var msg Message
	err := ReadMessage(bytes.NewReader(data), &msg)
	if err != nil {
		fmt.Println("Error reading message:", err)
		return RemoteHandleMessageReply, nil, err
	}
	replyData, err := h.pool.Process(id, msg)
	if err != nil {
		fmt.Println("Error handling message:", err)
	}
	if err != nil {
		return RemoteHandleMessageReply, nil, err
	}
	return RemoteHandleMessageReply, replyData, nil
}

func (h *GrainHandler) RemoteGetStateHandler(id CartId, data []byte) (uint16, []byte, error) {
	reply, err := h.pool.Get(id)
	if err != nil {
		return RemoteGetStateReply, nil, err
	}
	return RemoteGetStateReply, reply, nil
}