package main

import (
	"fmt"
	"os"

	"github.com/arobson/spry"
	"github.com/arobson/spry/memory"
	"github.com/arobson/spry/postgres"
	"github.com/arobson/spry/storage"
)

// Actors are how you model state in spry.

type Player struct {
	Name  string
	Score uint32
}

// All Actors must provide a method that identifies
// an actor uniquely based on it's state.
// Identifiers are a set of key/value pairs based on
// model state that uniquely identifiers the model.
// A field like Name is a decent choice (assuming you enforce uniqueness).
// Score would be a mistake to include!

func (p Player) GetIdentifiers() spry.Identifiers {
	return spry.Identifiers{"Name": p.Name}
}

// Actors may optionally implement a method that returns
// configuration details to the storage engine in spry
// to control how often and when spry should take a snapshot.

func (p Player) GetConfiguration() spry.ActorMeta {
	// defaults are shown below
	return spry.ActorMeta{
		snapshotFrequency: 			10, // produces snapshots often
		snapshotDuringRead: 		false, // prevents snapshotting during fetch (read)
		snapshotDuringWrite: 		true, // take snapshots during command handling (write)
		snapshotDuringPartition: 	true, // if supported by the storage adpater, 
										// snapshot even if a partition is detected
	}
}

// Commands are Verb-Noun named structures that target a specific
// Actor using the same function signature that Actors have.
// The command must carry enough information to correctly
// target a specific Actor instance.

type CreatePlayer struct {
	Name string
}

func (c CreatePlayer) GetIdentifiers() spry.Identifiers {
	return spry.Identifiers{"Name": c.Name}
}

// Commands must also provide a Handle method for accepting
// an Actor instance and determining how to handle that type
// of Actor. The Handle method must never mutate the Actor
// and should return either events or errors that describe
// why the command was invalid for a given actor state.
// Commands passed an actor type that isn't relevant should
// no-op and return empty arrays.

func (command CreatePlayer) Handle(actor any) ([]spry.Event, []error) {
	var events []spry.Event
	switch actor.(type) {
	case Player:
		events = append(events, PlayerCreated(command))
	}
	return events, []error{}
}

// Events must implement an Apply method, that similar to
// the Command's Handle, are expected to handle any Actor
// type passed to them. An Event's job is to mutate a copy
// of the Actor's state.

type PlayerCreated struct {
	Name string
}

// This shows that the Apply function can dispatch
// the application to a method on the Event or the Actor
// the point is that you have flexibility in how you
// model your application as long as each "primitive"
// implements the required methods.
func (e PlayerCreated) Apply(actor any) any {
	switch a := actor.(type) {
	case *Player:
		e.applyToPlayer(a)
	}
	return actor
}

func (e PlayerCreated) applyToPlayer(player *Player) {
	player.Score = 0
	player.Name = e.Name
}

// spry's API is exposed via a Repository instance.
// Repository's are strongly-typed to a single Actor type.
// Repository instances are created by a Storage implementation.
// Two implementations exist presently - InMemory (for simple testing)
// and Postgres.

// creating a Repository from an InMemoryStore
func FromMemory[T spry.Actor[T]]() spry.Repository[T] {
	memoryStore := memory.InMemoryStorage()
	return storage.GetRepositoryFor[T](memoryStore)
}

// creating a Repository from a PostgresStore
func FromPostgres[T spry.Actor[T]](connectionURI string) spry.Repository[T] {
	postgresStore := postgres.CreatePostgresStorage(connectionURI)
	// any disk backed stores will require you to register event types
	// with the storage mechanism so it will know how to correctly deserialize
	// those events on fetch
	postgresStore.RegisterPrimitives({
		PlayerCreated{}
	})
	return storage.GetRepositoryFor[T](postgresStore)
}

// Let's see how all this comes together when using the Repository API
func main() {
	// let's get our repository:

	// no errors are returned - storage instances will intentionally panic
	// and crash the process when a storage medium cannot be contacted
	players := FromPostgres[Player]("postgres://user:password@localhost:5432/dbname")

	// let's create Player
	results := players.Handle(CreatePlayer{Name: "A Super Unique Name"})

	// the results struct has 4 properties:
	// * Original - the initial state of the Actor instance
	// * Modified - the new state of the Actor (if any) that occurs after the
	//				Events produced by the Command (if any) are applied to the
	//				Original state of the Actor.
	// * Events	- the events that were produced by handling the
	//			  Command on the Actor given it's original state.
	// * Errors - the errors produced by by attempting to handle
	//			  the Command for the Actor in its Original state.
	//			  Errors are how your model should indicate that
	//			  a Command is not valid in the Actor's given state.
	fmt.Printf("Player created: %s\n", results.Modified.Name)

	// To get the present state of your Actor, you can call Fetch:
	myPlayer, err := players.Fetch(spry.Identifiers{"Name": "A Super Unique Name"})
	if err != nil {
		fmt.Println("failed to read player", err)
		os.Exit(1)
	}
	fmt.Printf("loaded player %s successfully", myPlayer.Name)
}