open System

let [<Literal>] private CategoryName = "InventoryItem"

let private streamId = FsCodec.StreamId.gen InventoryItemId.toString

type Event =

| Created of name: string

| Deactivated

| Renamed of newName: string

| Removed of count: int

| CheckedIn of count: int

interface TypeShape.UnionContract.IUnionContract

type State = { active: bool; name: string; quantity: int }

let initial: State = { active = true; name = null; quantity = 0 }

let private evolve state = function

| Events.Created name

| Events.Renamed name -> { state with name = name }

| Events.Deactivated -> { state with active = false }

| Events.Removed count -> { state with quantity = state.quantity - count }

| Events.CheckedIn count -> { state with quantity = state.quantity + count }

let fold = Array.fold evolve

type Command =

| Create of name: string

| ChangeName of newName: string

| Remove of count: int

| CheckIn of count: int

| Deactivate

let interpret command (state: Fold.State) = [|

match command with

| Create name ->

if String.IsNullOrEmpty name then invalidArg "name" ""

if state.name <> name then

Events.Created name

| ChangeName newName ->

if String.IsNullOrEmpty newName then invalidArg "newName" ""

if state.name <> newName then

Events.Renamed newName

| Remove count ->

if count <= 0 then invalidOp "cant remove negative count from inventory"

Events.Removed count

| CheckIn count ->

if count <= 0 then invalidOp "must have a count greater than 0 to add to inventory"

Events.CheckedIn count

| Deactivate ->

if not state.active then invalidOp "Already deactivated"

Events.Deactivated |]

type Service internal (resolve: InventoryItemId -> Equinox.Decider<Events.Event, Fold.State>) =

member _.Execute(itemId, command) =

let decider = resolve itemId

decider.Transact(interpret command)

member _.Read(itemId) =

let decider = resolve itemId

decider.Query id

let create resolve =

Service(streamId >> resolve)