using System;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        // normally I'd use MediatR and an IoC container for all this, but I'm just trying to show concepts here

        var commandHandler = new ReserveSeatCommandHandler();

        var seatNumbers = new List<int> {

            1, // this will succeed

            -1, // this is an invalid command altogether. never process it.

            4, // this could be valid, but its not for this stadium.

            1, // this seat has already been booked... so its an invalid action.

            2, // this will succeed

        };

        foreach(var seatNumber in seatNumbers)

        {

            try

            {

                // if the input from the user was never going to be valid, don't even bother with a command. Just tell them.

                if (seatNumber <= 0)

                    throw new Exception(string.Format("{0} is not a valid seat Number", seatNumber));

                // if the input does make for a valid request, create a command and send it to the handler for processing.

                var command = new ReserveSeatCommand { StadiumId = "abc", SeatNumber = seatNumber};

                commandHandler.Handle(command);

                Console.WriteLine(string.Format("Seat Number {0} reserved successfully", command.SeatNumber));

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message);

            }

        }

    }

    // most implementations have all data needed on the command object, but its not a bad implementation if you want to remove

    // the id of the aggregate and always pass that as an additional parameter to the command handler.

    // It's just less idiomatic.

    public class ReserveSeatCommand

    {

        public string StadiumId { get; set; }

        public int SeatNumber { get; set; }

    }

    // The purpose of the handler is to coordinate:

    // - getting the aggregate

    // - attempting to execute the command on it

    // - saving the aggregate.

    public class ReserveSeatCommandHandler

    {

        private readonly StadiumRepository repo;

        public ReserveSeatCommandHandler()

        {

            repo = new StadiumRepository();

        }

        public void Handle(ReserveSeatCommand cmd)

        {

            // use repo to request this stadium by id. This handles applying all events in the DB to get the stadium up-to-date

            // but I'm cheating because its just an example

            var stadium = repo.GetStadium(cmd.StadiumId);

            stadium.ReserveSeat(cmd.SeatNumber);

            // use repo to save - this would normally call on the aggregate to get all of its uncommitted events and store them (see Greg Young's example)

            repo.SaveStadium(stadium);

        }

    }

    // this is the Aggregate!!!!!

    public class Stadium

    {

        private string stadiumId = "abc";

        private Dictionary<int, bool> seatStatus = new Dictionary<int, bool>

        {

            { 1, false },

            { 2, false },

            { 3, false }

        };

        // notice that we handle commands here, not events.

        // Instead - we try to execute the command here.

        // THE AGGREGATE KNOWS ITS INTERNAL STATE AND ITS JOB IS TO MAKE SURE THAT THIS COMMAND

        // DOES NOT BREAK ANY OF ITS RULES. In this case, that means "you cannot reserve a seat that has already been reserved"

        public void ReserveSeat(int seatNumber)

        {

            if (!seatStatus.ContainsKey(seatNumber))

                throw new Exception("no seat for that number");

            var seatIsReserved = seatStatus[seatNumber];

            if (seatIsReserved)

                throw new Exception(string.Format("Seat Number {0} is already reserved.", seatNumber));

            // Notice the event is only ever created and applied AFTER we've passed all the business rules.

            // You don't create an event, attempt to apply it and then determine whether or not it was successful

            // The mere fact that the event comes into existence means that it HAS happened.

            ApplyEvent(new SeatReserved { StadiumId = stadiumId, SeatNumber = seatNumber });

        }

        // the event application method is private. Never executed from outside the aggregate.

        private void ApplyEvent(SeatReserved @event)

        {

            seatStatus[@event.SeatNumber] = true;

        }

    }

    public class SeatReserved

    {

        public string StadiumId { get; set; }

        public int SeatNumber { get; set; }

    }

    public class StadiumRepository

    {

        // I'm just faking out a way to always get the same stadium

        private Stadium stadium = new Stadium(); 

        public Stadium GetStadium(string StadiumID)

        {

            return stadium;

        }

        public void SaveStadium(Stadium stadium)

        {

            this.stadium = stadium;

        }

    }

}