package main

import (
	"bytes"
	"fmt"
)

type GrainHandler struct {
	*GenericListener
	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) {
	conn := NewConnection(listen)
	server, err := conn.Listen()
	handler := &GrainHandler{
		GenericListener: server,
		pool:            pool,
	}
	server.AddHandler(RemoteHandleMutation, handler.RemoteHandleMessageHandler)
	server.AddHandler(RemoteGetState, handler.RemoteGetStateHandler)
	return handler, err
}

func (h *GrainHandler) IsHealthy() bool {
	return len(h.pool.grains) < h.pool.PoolSize
}

func (h *GrainHandler) RemoteHandleMessageHandler(data *FrameWithPayload, resultChan chan<- FrameWithPayload) error {
	cartData, err := GetCartFrame(data.Payload)
	if err != nil {
		return err
	}
	var msg Message
	err = ReadMessage(bytes.NewReader(cartData.Data), &msg)
	if err != nil {
		fmt.Println("Error reading message:", err)
		return err
	}

	replyData, err := h.pool.Process(cartData.Id, msg)

	if err != nil {
		fmt.Println("Error handling message:", err)
	}
	resultChan <- *replyData
	return nil
}

func (h *GrainHandler) RemoteGetStateHandler(data *FrameWithPayload, resultChan chan<- FrameWithPayload) error {
	cartData, err := GetCartFrame(data.Payload)
	if err != nil {
		return err
	}
	reply, err := h.pool.Get(cartData.Id)
	if err != nil {
		return err
	}
	resultChan <- *reply
	return nil
}