package tools

import (
	"context"

	"github.com/modelcontextprotocol/go-sdk/mcp"

	"isphere-ai-bridge/internal/isphere"
)

const ToolNameReceiveMessages = "isphere_receive_messages"

type ReceiveMessagesSource interface {
	ReceiveMessages(ctx context.Context, query isphere.ReceiveMessagesQuery) (isphere.ReceiveMessagesResult, error)
}

type ReceiveMessagesArgs struct {
	Limit int `json:"limit,omitempty" jsonschema:"maximum number of messages to return; zero or negative returns all available messages"`
}

func RegisterISphereReadTools(server *mcp.Server, source ReceiveMessagesSource) {
	if source == nil {
		source = isphere.EncryptedPacketLogSource{}
	}

	mcp.AddTool[ReceiveMessagesArgs, map[string]any](server, &mcp.Tool{
		Name:        ToolNameReceiveMessages,
		Description: "Return iSphere messages from the configured read-only log-backed source.",
	}, func(ctx context.Context, _ *mcp.CallToolRequest, input ReceiveMessagesArgs) (*mcp.CallToolResult, map[string]any, error) {
		result, err := source.ReceiveMessages(ctx, isphere.ReceiveMessagesQuery{Limit: input.Limit})
		if err != nil {
			return nil, nil, err
		}
		return nil, receiveMessagesResultToMap(result), nil
	})
}

func receiveMessagesResultToMap(result isphere.ReceiveMessagesResult) map[string]any {
	messages := make([]map[string]any, 0, len(result.Messages))
	for _, message := range result.Messages {
		messages = append(messages, map[string]any{
			"id":                message.ID,
			"conversation_id":   message.ConversationID,
			"conversation_type": message.ConversationType,
			"sender_id":         message.SenderID,
			"receiver_id":       message.ReceiverID,
			"text":              message.Text,
			"timestamp":         message.Timestamp,
			"subject":           message.Subject,
			"receipt_id":        message.ReceiptID,
			"read":              message.Read,
		})
	}
	return map[string]any{"messages": messages}
}