sledgemapper/Sledgemapper.Shared/Entities/SessionData.cs

using System.Collections.Generic;
using System.Collections.Concurrent;
using System;

namespace Sledgemapper.Shared.Entities
{
    public class TileAddedEventArgs : EventArgs
    {
        public Tile Tile { get; set; }
        public TileAddedEventArgs(Tile tile) => Tile = tile;
    }

    public class OverlayAddedEventArgs : EventArgs
    {
        public Overlay Overlay { get; set; }
        public OverlayAddedEventArgs(Overlay overlay) => Overlay = overlay;
    }

    public class WallAddedEventArgs : EventArgs
    {
        public Wall Wall { get; set; }
        public WallAddedEventArgs(Wall wall) => Wall = wall;
    }

    public class WallDeletedEventArgs : EventArgs
    {
        public Wall Wall { get; set; }
        public WallDeletedEventArgs(Wall wall) => Wall = wall;
    }

    public class OverlayDeletedEventArgs : EventArgs
    {
        public Overlay Overlay { get; set; }
        public OverlayDeletedEventArgs(Overlay overlay) => Overlay = overlay;
    }

    public class TileDeletedEventArgs : EventArgs
    {
        public Tile Tile { get; set; }
        public TileDeletedEventArgs(Tile tile) => Tile = tile;
    }

    public class SessionData
    {
        public event EventHandler<TileAddedEventArgs> TileAdded;
        public event EventHandler<OverlayAddedEventArgs> OverlayAdded;
        public event EventHandler<WallAddedEventArgs> WallAdded;
        public event EventHandler<WallDeletedEventArgs> WallDeleted;
        public event EventHandler<OverlayDeletedEventArgs> OverlayDeleted;
        public event EventHandler<TileDeletedEventArgs> TileDeleted;

        public SessionData()
        {
            Map = new ConcurrentDictionary<string, Tile>();
            Overlays = new ConcurrentDictionary<string, Overlay>();
            Walls = new ConcurrentDictionary<string, Wall>();
            Players = new List<Player>();
            Colors = new List<string>();
        }

        public ConcurrentDictionary<string, Tile> Map { get; set; }
        public ConcurrentDictionary<string, Wall> Walls { get; set; }
        public ConcurrentDictionary<string, Overlay> Overlays { get; set; }
        public bool IsValid { get; set; }
        public List<Player> Players { get; set; }
        public List<string> Colors;

        public void NewTile(Tile selectedTile, string tileId)
        {
            if (selectedTile is null || string.IsNullOrWhiteSpace(tileId))
            {
                return;
            }

            var tileExist = Map.TryGetValue(selectedTile.ToString(), out var tile);
            var newTile = new Tile { X = selectedTile.X, Y = selectedTile.Y, ID = tileId };
            if (tileExist)
            {
                Map.TryRemove(tile.ToString(), out var _);
                if (tile.ID == tileId)
                {
                    newTile.Rotation = (tile.Rotation + 1) % 4;
                }
            }

            Map.TryAdd(newTile.ToString(), newTile);
            OnRaiseTileAddedEvent(new TileAddedEventArgs(newTile));
        }

        public void NewOverlay(Overlay selectedOverlay, string overlayId)
        {
            if (selectedOverlay is null || string.IsNullOrWhiteSpace(overlayId))
            {
                return;
            }
            var overlayExist = Overlays.TryGetValue(selectedOverlay.ToString(), out var overlay);
            var newOverlay = new Overlay { X = selectedOverlay.X, Y = selectedOverlay.Y, ID = overlayId, Intersection = selectedOverlay.Intersection }; ;
            if (overlayExist)
            {
                Overlays.TryRemove(overlay.ToString(), out var rrtile);
                if (overlay.ID == overlayId)
                {
                    newOverlay.Rotation = (overlay.Rotation + 1) % 4;
                }
            }

            Overlays.TryAdd(newOverlay.ToString(), newOverlay);
            OnRaiseOverlayAddedEvent(new OverlayAddedEventArgs(newOverlay));
        }

        public void NewWall(Wall selectedWall, string wallId)
        {
            if (selectedWall is null || string.IsNullOrWhiteSpace(wallId))
            {
                return;
            }
            var tileExist = Walls.TryGetValue(selectedWall.ToString(), out var wall);
            var newWall = new Wall { X = selectedWall.X, Y = selectedWall.Y, ID = wallId, Rotation = selectedWall.Rotation };
            if (tileExist)
            {
                Walls.TryRemove(wall.ToString(), out var _);
            }

            Walls.TryAdd(newWall.ToString(), newWall);
            OnRaiseWallAddedEvent(new WallAddedEventArgs(newWall));
        }

        public void DeleteWall(Wall wall)
        {
            if (wall is null)
            {
                return;
            }
            var removed = Walls.TryRemove(wall.ToString(), out var _);
            if (removed)
            {
                OnRaiseWallDeletedEvent(new WallDeletedEventArgs(wall));
            }
        }

        public void DeleteOverlay(Overlay overlay)
        {
              if (overlay is null)
            {
                return;
            }
            var removed = Overlays.TryRemove(overlay.ToString(), out var _);
            if (removed)
            {
                OnRaiseOverlayDeletedEvent(new OverlayDeletedEventArgs(overlay));
            }
        }

        public void DeleteTile(Tile tile)
        {
              if (tile is null)
            {
                return;
            }
            var removed = Map.TryRemove(tile.ToString(), out var _);
            if (removed)
            {
                OnRaiseTileDeletedEvent(new TileDeletedEventArgs(tile));
            }
        }

        protected virtual void OnRaiseTileAddedEvent(TileAddedEventArgs e)
        {
            var raiseEvent = TileAdded;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }

        protected virtual void OnRaiseOverlayAddedEvent(OverlayAddedEventArgs e)
        {
            var raiseEvent = OverlayAdded;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }

        protected virtual void OnRaiseWallAddedEvent(WallAddedEventArgs e)
        {
            var raiseEvent = WallAdded
            ;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }
        protected virtual void OnRaiseWallDeletedEvent(WallDeletedEventArgs e)
        {
            var raiseEvent = WallDeleted;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }
        protected virtual void OnRaiseOverlayDeletedEvent(OverlayDeletedEventArgs e)
        {
            var raiseEvent = OverlayDeleted;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }
        protected virtual void OnRaiseTileDeletedEvent(TileDeletedEventArgs e)
        {
            var raiseEvent = TileDeleted;
            if (raiseEvent != null)
            {
                raiseEvent(this, e);
            }
        }
    }
}