/// <summary>一个结构体，记录当前聚合根的当前版本号，以及用于并发控制的一些状态信息
/// </summary>
class AggregateVersionInfo
{
    public const int Editing = 1;    //一个常量，表示当前聚合根的当前版本号正在被修改
    public const int UnEditing = 0;  //一个常量，表示当前聚合根的当前版本号未在被修改

    public int CurrentVersion = 0;   //记录当前聚合根的当前版本号，初始值为0，其实就是事件的个数
    public int Status = UnEditing;   //默认状态，未被修改
}
class Program
{
    static void Main(string[] args)
    {
        var aggregateCount = 4;                    //用于测试的聚合根的个数
        var eventCountPerAggregate = 10;           //单个聚合根产生的事件数
        var aggregateIdList = new List<string>();  //一个List，存放所有聚合根的ID
        var aggregateCurrentVersionDict = new ConcurrentDictionary<string, AggregateVersionInfo>();  //一个Dict，用于保存所有聚合根的当前版本信息
        var aggregateEventsDict = new Dictionary<string, IList<int>>();                      //一个Dict，用于模拟存储每个聚合根的所有事件

        //先生成所有聚合根ID
        for (var index = 1; index <= aggregateCount; index++)
        {
            aggregateIdList.Add("key-" + index);
        }
        //初始化每个聚合根的当前状态
        foreach (var aggregateId in aggregateIdList)
        {
            aggregateCurrentVersionDict[aggregateId] = new AggregateVersionInfo();
            aggregateEventsDict[aggregateId] = new List<int>();
        }

        //该方法用于实现事件的并发冲突检测和持久化逻辑。
        Action<string, int> persistEventAction = (aggregateId, currentEventVersion) =>
        {
            var aggregateVersionInfo = aggregateCurrentVersionDict[aggregateId];
            var originalStatus = Interlocked.CompareExchange(
                ref aggregateVersionInfo.Status,
                AggregateVersionInfo.Editing,
                AggregateVersionInfo.UnEditing);

            //这里两者不相等，说明aggregateVersionInfo.Status成功更新为Editing了
            if (originalStatus != aggregateVersionInfo.Status)
            {
                if (currentEventVersion == aggregateVersionInfo.CurrentVersion + 1)
                {
                    //这里，将事件加入到一个List，真实的eventstore会在这里持久化事件到文件；
                    aggregateEventsDict[aggregateId].Add(currentEventVersion);
                    //更新聚合根的最新版本
                    aggregateVersionInfo.CurrentVersion++;
                }
                else
                {
                    //进入这里，说明有别的线程已经添加了该版本，也就是遇到并发冲突了。
                }

                //处理完后，将聚合根的版本状态修改回UnEditing
                Interlocked.Exchange(ref aggregateVersionInfo.Status, AggregateVersionInfo.UnEditing);
            }
            else
            {
                //进入这里，说明有别的线程正在更改当前聚合根的版本信息，也可以认为是遇到并发冲突了。
            }
        };

        //该方法用于模拟并行产生事件并调用事件的持久化逻辑
        Action generateEventAction = () =>
        {
            foreach (var aggregateId in aggregateIdList) //循环处理每个聚合根
            {
                //对每个聚合根产生指定个数的事件，为了简化，仅使用事件版本号表示事件了
                for (var eventVersion = 1; eventVersion <= eventCountPerAggregate; eventVersion++)
                {
                    for (var i = 0; i < 100000; i++) //这里纯粹为了性能测试，对每个事件再循环10W次调用持久化逻辑
                    {
                        persistEventAction(aggregateId, eventVersion); //调用持久化方法持久化聚合根的当前事件
                    }
                }
            }    
        };

        var watch = Stopwatch.StartNew();
        //模拟同时4个线程同时产生事件并持久化，这里其实只要开2个够了，因为我的笔记本只有2个核
        Parallel.Invoke(generateEventAction, generateEventAction, generateEventAction, generateEventAction);
        watch.Stop();
        var time = watch.ElapsedMilliseconds;

        //最后输出结果，输出总运行时间，以及验证每个聚合根的当前版本以及聚合根的每个事件的版本是否是顺序逐个递增的。
        Console.WriteLine("total time:{0}ms", time);
        foreach (var aggregateId in aggregateIdList)
        {
            Console.WriteLine("aggregateId:{0}, currentVersion:{1}, events:{2}",
                aggregateId,
                aggregateCurrentVersionDict[aggregateId].CurrentVersion,
                string.Join(",", aggregateEventsDict[aggregateId].ToArray()));
        }

        Console.ReadLine();
    }
}