using System;
using System.Collections.ObjectModel;
using Aurora.Executors;
using Aurora.Proto.Party;
using Xamarin.Forms;

namespace Aurora.Design.Views.Party
{
    enum PartyState
    {
        SelectingHost,
        InParty,
        Connecting,
    }

    public class PartyViewModel : BaseViewModel
    {
        private PartyState _state;

        private BaseExecutor _executor;

        private string _hostname;

        private ObservableCollection<PartyMember> _members;


        public PartyViewModel()
        {
            this.JoinCommand = new Command(OnJoinExecute, CanJoinExecute);
            this.HostCommand = new Command(OnHostExecute, CanHostExecute);
            _members = new ObservableCollection<PartyMember>
            {
                new PartyMember{UserName = "asdf"}
            };


            State(PartyState.SelectingHost);
        }

        ~PartyViewModel()
        {
            if (_executor != null)
            {
                _executor.Close();
            }
        }

        #region Properties

        public ObservableCollection<PartyMember> Members
        {
            get
            {
                return _members;
            }
            set
            {
                SetProperty(ref _members, value);
            }
        }

        public bool IsSelectingHost
        {
            get { return _state == PartyState.SelectingHost; }
        }

        public bool IsNotSelectingHost
        {
            get { return _state != PartyState.SelectingHost; }
        }

        public Command JoinCommand { get; set; }
        public Command HostCommand { get; set; }

        public string Hostname
        {
            get { return _hostname; }
            set { SetProperty(ref _hostname, value); }
        }

        #endregion Properties


        private void State(PartyState state)
        {
            _state = state;
            OnPropertyChanged("IsSelectingHost");
            OnPropertyChanged("IsNotSelectingHost");
        }

        #region Commands
        private void OnJoinExecute()
        {
            _executor = BaseExecutor.CreateExecutor<ClientExecutor>();
            _executor.Connect(this.Hostname);

            SetupMembersCollection();
            OnPropertyChanged("Members");

            State(PartyState.Connecting);
        }

        private bool CanJoinExecute()
        {
            return true;
        }

        private void OnHostExecute()
        {

            //Instantiate and initialize all executors
            _executor = BaseExecutor.CreateExecutor<HostExecutor>();
            _executor.Connect(this.Hostname);

            SetupMembersCollection();
            OnPropertyChanged("Members");

            //Change state
            State(PartyState.Connecting);
        }

        private bool CanHostExecute()
        {
            return true;
        }


        #endregion Commands

        private void SetupMembersCollection()
        {
            if (_executor != null)
            {
                foreach (PartyMember member in _executor.PartyMembers)
                {
                    _members.Add(member);
                }

                //Setup events
                _executor.PartyMembers.CollectionChanged += (sender, e) =>
                {
                    switch (e.Action)
                    {
                        case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                            {
                                foreach (PartyMember member in e.NewItems)
                                {
                                    Members.Add(member);
                                    OnPropertyChanged("Members");
                                }
                                break;
                            }
                        case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                            {
                                foreach (PartyMember member in e.OldItems)
                                {
                                    Members.Remove(member);
                                    OnPropertyChanged("Members");
                                }
                                break;
                            }
                    }
                };
            }
        }
    }
}