Resources

package main

import (
	"fmt"
	"net/url"
	"time"

	"github.com/localrivet/gomcp/protocol"
	"github.com/localrivet/gomcp/server"
	// ... other imports
)

// Static resource handler
func handleAppVersion(uri *url.URL) (protocol.Content, error) {
	return server.Text("1.2.3"), nil
}

// Dynamic resource handler (extracting part from URI)
func handleUserData(uri *url.URL) (protocol.Content, error) {
	// Example URI: user://data/123/profile
	// We need to parse the user ID from the path
	userID := "" // Extract from uri.Path, e.g., using strings.Split
	// Fetch user data...
	userData := map[string]interface{}{
		"id":        userID,
		"email":     fmt.Sprintf("user%s@example.com", userID),
		"lastLogin": time.Now().Format(time.RFC3339),
	}
	return server.JSON(userData) // Helper for JSON responses
}


func registerResources(srv *server.Server) error {
	// Register a static resource
	err := srv.AddResource(protocol.ResourceDefinition{
		URI:         "app://info/version",
		Description: "Get the application version.",
		Handler:     handleAppVersion,
	})
	if err != nil { return err }

	// Register a dynamic resource template
	err = srv.AddResource(protocol.ResourceDefinition{
		URI:         "user://data/{userID}/profile", // Template URI
		Description: "Get user profile data.",
		IsTemplate:  true, // Mark as template
		Handler:     handleUserData,
	})
	return err
}

type SubscribeResourceParams struct {
	URIs []string `json:"uris"` // List of resource URIs to subscribe to
}

type SubscribeResourceResult struct{} // Currently empty

type UnsubscribeResourceParams struct {
	URIs []string `json:"uris"` // List of resource URIs to unsubscribe from
}

type UnsubscribeResourceResult struct{} // Currently empty

type ReadResourceRequestParams struct {
	URI     string `json:"uri"`
	Version string `json:"version,omitempty"` // Optional version to request a specific version
}

type ReadResourceResult struct {
	Resource protocol.Resource         `json:"resource"` // The resource metadata (should match the request URI/version)
	Contents protocol.ResourceContents `json:"contents"` // The actual content (Text, Blob, or Audio)
}

type ResourceUpdatedParams struct {
	Resource Resource `json:"resource"` // The updated resource metadata
}

type ResourcesListChangedParams struct{} // Currently empty

// Assume srv is your initialized *server.Server instance
// Assume updatedResource is the protocol.Resource with the new metadata/version

func updateResourceAndNotify(srv *server.Server, updatedResource protocol.Resource) {
    // First, update the resource's metadata in the server's registry.
    // RegisterResource also updates if a resource with the same URI already exists.
    err := srv.RegisterResource(updatedResource)
    if err != nil {
        log.Printf("Failed to update resource '%s': %v", updatedResource.URI, err)
        return
    }
    log.Printf("Updated resource metadata: %s", updatedResource.URI)

    // Then, notify subscribed clients about the update.
    // The server will automatically send a notifications/resources/updated
    // message to all sessions that subscribed to this resource's URI.
    srv.NotifyResourceUpdated(updatedResource)
    log.Printf("Sent resources/updated notification for: %s", updatedResource.URI)

    // Note: Clients receiving this notification will typically then send a
    // resources/read request to get the new content if they need it.
}