GreadyPoang/GreadyPoang.ViewModelLayer/ViewModelClasses/RoundRunningViewModel.cs

using Common.Library;
using GreadyPoang.DataLayer;
using GreadyPoang.EntityLayer;
using GreadyPoang.Services;
using System.Collections.ObjectModel;
using System.Diagnostics;

namespace GreadyPoang.ViewModelLayer;

public class RoundRunningViewModel : ViewModelBase
{

    public event EventHandler RebuildRequested;

    public RoundRunningViewModel() : base()
    {
    }

    public RoundRunningViewModel(

        IRepository<GameRound> roundsRepo,
        IRepository<GamePoint> pointsRepo,
        IMethodSharingService<Participant> sharingService,
        ICombinedRepository combined,
        IObjectMessageService objectMessage
        ) : base()
    {
        _roundsRepo = roundsRepo;
        _pointsRepo = pointsRepo;
        _sharingService = sharingService;
        _combined = combined;
        _objectMessage = objectMessage;
        _roundElements = new ObservableCollection<RoundBuilderElement>();
        _builderObject = new();
    }

    private readonly IRepository<GameRound>? _roundsRepo;
    private readonly IRepository<GamePoint> _pointsRepo;
    private readonly IMethodSharingService<Participant> _sharingService;
    private readonly ICombinedRepository _combined;
    private readonly IObjectMessageService _objectMessage;
    private ObservableCollection<RoundBuilderElement> _roundElements;

    private ObservableCollection<RoundBuilderGroup> _GameRoundList = new();
    private ObservableCollection<Participant> _ParticipantList = new();
    private Collection<PlayerColumn> _playerColumns;

    public void TriggerRebuild()
    {
        // Trigga eventet
        RebuildRequested?.Invoke(this, EventArgs.Empty);
    }

    public ObservableCollection<RoundBuilderElement> RoundElements
    {
        get { return _roundElements; }
        set
        {
            _roundElements = value;
            RaisePropertyChanged(nameof(RoundElements));
        }
    }

    public Collection<PlayerColumn> PlayerColumns
    {
        get { return _playerColumns; }
        set
        {
            _playerColumns = value;
            RaisePropertyChanged(nameof(PlayerColumns));
        }
    }



    private RoundBuilderElement _builderObject;

    public RoundBuilderElement BuilderObject
    {
        get { return _builderObject; }
        set
        {
            _builderObject = value;
            RaisePropertyChanged(nameof(BuilderObject));
        }
    }


    public ObservableCollection<RoundBuilderElement> Get()
    {


        if (_objectMessage.CurrentGroup != null)
        {
            //CurrentGroup är satt från RoundStarting ViewModel
            Debug.WriteLine($"Chosen round: {_objectMessage.CurrentGroup.GameRoundId}");
            if (RoundElements.Count > 0)
            {
                RoundElements.Clear();
            }
            foreach (var item in _objectMessage.CurrentGroup.Elements)
            {
                _roundElements.Add(item);
            }

            var nxt = nextPlayerElement();
            BuilderObject.ParticipantName = _objectMessage.CurrentGroup.Elements[nxt].ParticipantName;
            BuilderObject.GameRoundId = _objectMessage.CurrentGroup.GameRoundId;
            BuilderObject.ParticipantId = _objectMessage.CurrentGroup.Elements[nxt].ParticipantId;

            var localElements = _combined.roundBuilderElementsTotalById(_objectMessage.CurrentGroup.GameRoundId);
            FillupResultTable(localElements);

        }
        return RoundElements;
    }


    public void StoreAndHandlePoints()
    {
        var regNr = RoundElements.Count > 0 ? RoundElements.Max(e => e.GameRoundRegNr) + 1 : 1;
        var points = BuilderObject.GameRegPoints;
        var newPoint = new GamePoint
        {
            ParticipantId = BuilderObject.ParticipantId,
            GameRoundId = BuilderObject.GameRoundId,
            GameDate = DateTime.Now,
            GameRoundRegNr = regNr,
            GameRegPoints = points
        };
        var pointId = _pointsRepo?.Save(newPoint).GetAwaiter().GetResult();

        // Uppdatera listan med element
        var tmpElements = _combined.roundBuilderElementsDbById(BuilderObject.GameRoundId);
        RoundElements.Clear();
        foreach (var item in tmpElements)
        {
            RoundElements.Add(item);
        }

        // Uppdatera spelaren som skall spela nästa
        var nxt = nextPlayerElement();
        BuilderObject.GameRegPoints = 0;
        BuilderObject.ParticipantName = RoundElements[nxt].ParticipantName;
        BuilderObject.ParticipantId = RoundElements[nxt].ParticipantId;
        BuilderObject.GameRoundId = RoundElements[0].GameRoundId;

        var localElements = _combined.roundBuilderElementsTotalById(BuilderObject.GameRoundId);
        FillupResultTable(localElements);
        foreach (var col in _playerColumns)
        {
            RoundElements.FirstOrDefault(e => e.ParticipantId == col.PlayerId).GameRegPoints = col.PlayerPoints;
        }
        TriggerRebuild();
    }

    private int nextPlayerElement()
    {
        for (int i = 0; i < RoundElements.Count; i++)
        {
            if (RoundElements[i].GameRoundRegNr == -1 ||
               (i > 0 && (RoundElements[i - 1].GameRoundRegNr > RoundElements[i].GameRoundRegNr)) ||
                   (i == 0 && RoundElements[i].GameRoundRegNr < RoundElements[RoundElements.Count - 1].GameRoundRegNr))
                return i;
        }
        return -1;
    }



    private void FillupResultTable(IEnumerable<RoundBuilderElement> elements)
    {
        if (_playerColumns != null)
        {
            _playerColumns.Clear();
        }
        else
        {
            _playerColumns = new Collection<PlayerColumn>();
        }

        if (elements.Any(g => g.GameRegPoints > 0))
        {
            PlayerColumn player = new PlayerColumn();

            foreach (var element in elements)
            {
                player = _playerColumns.FirstOrDefault(p => p.PlayerId == element.ParticipantId);

                if (player == null)
                {
                    player = new PlayerColumn
                    {
                        PlayerName = element.ParticipantName,
                        PlayerId = element.ParticipantId,
                        PlayerPoints = 0
                    };
                }

                if (element.GameRegPoints > 0)
                {
                    player.Values.Add(element.GameRegPoints.ToString());
                    player.PlayerPoints += element.GameRegPoints;
                }
                //oldPart = element.ParticipantId;

                if (!_playerColumns.Contains(player))
                {
                    _playerColumns.Add(player);
                }
            }
        }
        else
        {
            Random slumper = new Random();

            foreach (var element in elements)
            {
                var player = new PlayerColumn
                {
                    PlayerName = element.ParticipantName
                };

                for (int i = 0; i < slumper.Next(6); i++)
                {
                    player.Values.Add(slumper.Next(1, 10).ToString());
                }

                _playerColumns.Add(player);
            }
        }
    }

}