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) {
	data, err := h.pool.Get(id)
	if err != nil {
		return RemoteGetStateReply, nil, err
	}
	return RemoteGetStateReply, data, nil
}

// func (h *GrainHandler) handleClient(conn net.Conn) {
// 	var err error

// 	defer conn.Close()

// 	var packet CartPacket

// 	for {
// 		err = binary.Read(conn, binary.LittleEndian, &packet)
// 		if err != nil {
// 			if err == io.EOF {
// 				break
// 			}
// 			fmt.Println("Error in connection:", err)
// 		}
// 		if packet.Version != 2 {
// 			fmt.Printf("Unknown version %d", packet.Version)
// 			break
// 		}

// 		switch packet.MessageType {
// 		case RemoteHandleMessage:
// 			var msg Message
// 			err = ReadMessage(conn, &msg)
// 			if err != nil {
// 				fmt.Println("Error reading message:", err)
// 			}

// 			data, err := h.pool.Process(packet.Id, msg)
// 			if err != nil {
// 				fmt.Println("Error handling message:", err)
// 			}
// 			SendRawResponse(conn, data)

// 		case RemoteGetState:
// 			data, err := h.pool.Get(packet.Id)
// 			if err != nil {
// 				fmt.Println("Error getting grain:", err)
// 			}
// 			SendRawResponse(conn, data)
// 		}

// 	}

// }