GreadyPoang/GreadyPoang.ViewModelLayer/ViewModelClasses/RoundStartingViewModel.cs

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

namespace GreadyPoang.ViewModelLayer;

public class RoundStartingViewModel : ViewModelBase
{
    #region Constructors
    public RoundStartingViewModel() : base()
    {

    }

    public RoundStartingViewModel(
        IRepository<GameRound> repo,
        IRepository<GamePoint> pointsRepo,
        IMethodSharingService<Participant> sharingService,
        ICombinedRepository combined) : base()
    {
        _Repository = repo;
        _pointsRepo = pointsRepo;
        _sharingService = sharingService;
        _combined = combined;
        _roundElements = new ObservableCollection<RoundBuilderElement>();
    }

    #endregion

    private GameRound? _GameRoundObject = new();
    private ObservableCollection<IEnumerable<GameRound>> _GameRoundList = new();
    private ObservableCollection<Participant> _ParticipantList = new();
    private readonly IRepository<GameRound>? _Repository;
    private readonly IRepository<GamePoint> _pointsRepo;
    private readonly IMethodSharingService<Participant> _sharingService;
    private readonly ICombinedRepository _combined;
    private Participant _selectedItem;

    private ObservableCollection<RoundBuilderElement> _roundElements;

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


    public Participant SelectedItem
    {
        get => _selectedItem;
        set
        {
            if (_selectedItem != value)
            {

                _selectedItem = value;
                RaisePropertyChanged(nameof(SelectedItem));
                OnItemSelected(value); // Metod som triggas vid val
            }
        }
    }

    private void OnItemSelected(Participant item)
    {
        if (_roundElements.Count == 0)
        {
            var GameRound = new GameRound
            {
                GameRoundStartDate = DateTime.Now,
                GameStatus = GamePointStatus.New,
                GameRoundFinished = null
            };
            var gameRoundId = _Repository?.Save(GameRound).GetAwaiter().GetResult();
            if (gameRoundId != null && gameRoundId != -1)
            {
                GameRound.GameRoundId = gameRoundId.Value;
            }
            GameRoundObject = GameRound;
        }

        var GamePointStart = new GamePoint
        {
            ParticipantId = item.ParticipantId,
            GameRoundId = GameRoundObject?.GameRoundId ?? 0,
            GameDate = DateTime.Now,
            GameRoundRegNr = -1,
            GameRegPoints = 0
        };

        var gamePointId = _pointsRepo.Save(GamePointStart).GetAwaiter().GetResult();
        GamePointStart.GamePointId = gamePointId;

        var newElement = new RoundBuilderElement();
        newElement.ParticipantId = item.ParticipantId;
        newElement.ParticipantName = item.LastNameFirstName;
        newElement.GameRoundRegNr = GamePointStart.GameRoundRegNr;
        newElement.GameRegPoints = GamePointStart.GameRegPoints;
        newElement.Status = GameRoundObject!.GameStatus;
        newElement.GameRoundStartDate = GameRoundObject?.GameRoundStartDate ?? DateTime.Now;
        newElement.GameRoundId = GamePointStart.GameRoundId;
        newElement.GamePointId = GamePointStart.GamePointId;

        _roundElements.Add(newElement);
        // Gör något med det valda objektet
        Debug.WriteLine($"Du valde: {item.LastNameFirstName}");
    }


    public GameRound? GameRoundObject
    {
        get { return _GameRoundObject; }
        set
        {
            _GameRoundObject = value;
            RaisePropertyChanged(nameof(GameRoundObject));
        }
    }

    public ObservableCollection<IEnumerable<GameRound>> GameRoundList
    {
        get { return _GameRoundList; }
        set
        {
            _GameRoundList = value;
            RaisePropertyChanged(nameof(GameRoundList));
        }
    }

    public ObservableCollection<Participant> ParticipantList
    {
        get { return _ParticipantList; }
        set
        {
            _ParticipantList = value;
            RaisePropertyChanged(nameof(ParticipantList));
        }
    }

    #region Get Method
    public ObservableCollection<GameRound> Get()
    {
        //if (_Repository != null)
        if (_combined != null)
        {
            //var gameRoundsTask = _Repository.Get();
            //var gameRounds = gameRoundsTask is Task<IEnumerable<GameRound>> task
            //    ? task.GetAwaiter().GetResult()
            //    : (IEnumerable<GameRound>)gameRoundsTask;

            var GameRoundSummary = _combined.roundBuilderElements();

            var groupedRounds = GameRoundSummary
                .GroupBy(r => r.GameRoundId)
                .Select(g => g.ToList())
                .ToList();

            //OBS ! Här måste jag skapa en ny lista varje gång för att UI ska uppdateras korrekt


            //foreach (var gameRound in gameRounds)
            //{
            //    if (!_GameRoundList.Any(p => p.GameRoundId == gameRound.GameRoundId))
            //    {
            //        GameRoundList.Add(gameRound);
            //    }
            //}
        }
        return GameRoundList;
    }

    public ObservableCollection<Participant> GetParticipants()
    {
        ParticipantList = _sharingService.Get();
        return ParticipantList;
    }

    #endregion

    #region Get(id) Method
    public GameRound? Get(int id)
    {
        try
        {
            GameRoundObject = _Repository?.Get(id).GetAwaiter().GetResult();
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine($"Error in Get method: {ex.Message}");
        }

        return GameRoundObject;
    }
    public virtual bool Save()
    {
        if (_Repository == null || GameRoundObject == null)
        {
            return false;
        }
        var tmpTask = _Repository.Save(GameRoundObject);
        bool tmp = tmpTask.GetAwaiter().GetResult() != -1;
        if (tmp)
        {
            GameRoundObject = new GameRound();
            RoundElements.Clear();
            this.Get();
        }
        return tmp;
    }

    public void Rensa()
    {
        foreach (var element in RoundElements)
        {
            _pointsRepo.DeleteById(element.GamePointId);
        }
        _Repository?.DeleteById(GameRoundObject?.GameRoundId ?? 0);
        RoundElements.Clear();
    }

    #endregion

}