package main

import (
	"fmt"
	"strings"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
)

func (id CartId) String() string {
	return strings.Trim(string(id[:]), "\x00")
}

func ToCartId(id string) CartId {
	var result [16]byte
	copy(result[:], []byte(id))
	return result
}

type RemoteGrain struct {
	*CartClient
	Id   CartId
	Host string
}

func NewRemoteGrain(id CartId, host string) (*RemoteGrain, error) {
	client, err := CartDial(fmt.Sprintf("%s:1337", host))
	if err != nil {
		return nil, err
	}

	return &RemoteGrain{
		Id:         id,
		Host:       host,
		CartClient: client,
	}, nil
}

var (
	remoteCartLatency = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_remote_grain_calls_total_latency",
		Help: "The total latency of remote grains",
	})
	remoteCartCallsTotal = promauto.NewCounter(prometheus.CounterOpts{
		Name: "cart_remote_grain_calls_total",
		Help: "The total number of calls to remote grains",
	})
)

var start time.Time

func MeasureLatency(fn func() (*CallResult, error)) (*CallResult, error) {
	start = time.Now()
	data, err := fn()
	if err != nil {
		return data, err
	}
	elapsed := time.Since(start).Milliseconds()
	go func() {
		remoteCartLatency.Add(float64(elapsed))
		remoteCartCallsTotal.Inc()
	}()
	return data, nil
}

func (g *RemoteGrain) HandleMessage(message *Message, isReplay bool) (*CallResult, error) {

	data, err := GetData(message.Write)
	if err != nil {
		return nil, err
	}
	reply, err := MeasureLatency(func() (*CallResult, error) {
		return g.Call(RemoteHandleMutation, g.Id, RemoteHandleMutationReply, data)
	})

	if err != nil {
		return nil, err
	}

	return reply, err
}

func (g *RemoteGrain) GetId() CartId {
	return g.Id
}

func (g *RemoteGrain) GetCurrentState() (*CallResult, error) {
	return MeasureLatency(func() (*CallResult, error) { return g.Call(RemoteGetState, g.Id, RemoteGetStateReply, []byte{}) })
}