using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ProjetTheAlone.Classes;
using ProjetTheAlone.Gestion;
using System.Collections.ObjectModel;
using System.IO;
using ProjetTheAlone.Config;

namespace ProjetTheAlone.ViewModel
{
    public class VM_Event : BasePropriete
    {
        #region Données Écran

        private string chConnexion = Settings2.Default.schCon /*@"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename='C:\Users\Hugues\Haute Ecole de la ville de Liège\Adrien VAN DAMME - ProjetTheAlone\ProjetTheAlone\ProjetThe.mdf';Integrated Security = True"*/;
        private int nAjout;
        private bool _ActiverUneFiche;
        public bool ActiverUneFiche
        {
            get { return _ActiverUneFiche; }
            set
            {
                AssignerChamp<bool>(ref _ActiverUneFiche, value, System.Reflection.MethodBase.GetCurrentMethod().Name);
                ActiverBcpFiche = !ActiverUneFiche;
            }
        }
        private bool _ActiverBcpFiche;
        public bool ActiverBcpFiche
        {
            get { return _ActiverBcpFiche; }
            set { AssignerChamp<bool>(ref _ActiverBcpFiche, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        #endregion
        #region Données Sélectionnée
        private C_T_event _EventSelectionnee;
        public C_T_event EventSelectionnee
        {
            get { return _EventSelectionnee; }
            set { AssignerChamp<C_T_event>(ref _EventSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private C_T_listParticipant _JoueurSelectionnee;
        public C_T_listParticipant JoueurSelectionnee
        {
            get { return _JoueurSelectionnee; }
            set { AssignerChamp<C_T_listParticipant>(ref _JoueurSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private C_T_equipe _EquipeSelectionnee;
        public C_T_equipe EquipeSelectionnee
        {
            get { return _EquipeSelectionnee; }
            set { AssignerChamp<C_T_equipe>(ref _EquipeSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private C_T_typeEvenement _TypeEventSelectionnee;
        public C_T_typeEvenement TypeEventSelectionnee
        {
            get { return _TypeEventSelectionnee; }
            set { AssignerChamp<C_T_typeEvenement>(ref _TypeEventSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private C_T_lieu _LieuSelectionnee;
        public C_T_lieu LieuSelectionnee
        {
            get { return _LieuSelectionnee; }
            set { AssignerChamp<C_T_lieu>(ref _LieuSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private C_T_beneficiaire _ParticipantSelectionnee;
        public C_T_beneficiaire ParticipantSelectionnee
        {
            get { return _ParticipantSelectionnee; }
            set { AssignerChamp<C_T_beneficiaire>(ref _ParticipantSelectionnee, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        #endregion
        #region Données extérieures
        private VM_UnEvent _UnEvent;
        public VM_UnEvent UnEvent
        {
            get { return _UnEvent; }
            set { AssignerChamp<VM_UnEvent>(ref _UnEvent, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private ObservableCollection<C_T_event> _BcpEvents = new ObservableCollection<C_T_event>();
        public ObservableCollection<C_T_event> BcpEvents
        {
            get { return _BcpEvents; }
            set { AssignerChamp<ObservableCollection<C_T_event>>(ref _BcpEvents, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private VM_UnLieu _UnLieu;
        public VM_UnLieu UnLieu
        {
            get { return _UnLieu; }
            set { AssignerChamp<VM_UnLieu>(ref _UnLieu, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private ObservableCollection<C_T_lieu> _BcpLieux = new ObservableCollection<C_T_lieu>();
        public ObservableCollection<C_T_lieu> BcpLieux
        {
            get { return _BcpLieux; }
            set { AssignerChamp<ObservableCollection<C_T_lieu>>(ref _BcpLieux, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private VM_UneEquipe _UneEquipe;
        public VM_UneEquipe UneEquipe
        {
            get { return _UneEquipe; }
            set { AssignerChamp<VM_UneEquipe>(ref _UneEquipe, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private ObservableCollection<C_T_equipe> _BcpEquipes = new ObservableCollection<C_T_equipe>();
        public ObservableCollection<C_T_equipe> BcpEquipes
        {
            get { return _BcpEquipes; }
            set { AssignerChamp<ObservableCollection<C_T_equipe>>(ref _BcpEquipes, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private VM_UnTypeEvent _UnTypeEvent;
        public VM_UnTypeEvent UnTypeEvent
        {
            get { return _UnTypeEvent; }
            set { AssignerChamp<VM_UnTypeEvent>(ref _UnTypeEvent, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private ObservableCollection<C_T_typeEvenement> _BcpTypeEvents = new ObservableCollection<C_T_typeEvenement>();
        public ObservableCollection<C_T_typeEvenement> BcpTypeEvents
        {
            get { return _BcpTypeEvents; }
            set { AssignerChamp<ObservableCollection<C_T_typeEvenement>>(ref _BcpTypeEvents, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private VM_UnBeneficiaire _UnParticipant;
        public VM_UnBeneficiaire UnParticipant
        {
            get { return _UnParticipant; }
            set { AssignerChamp<VM_UnBeneficiaire>(ref _UnParticipant, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private ObservableCollection<C_T_beneficiaire> _BcpParticipants = new ObservableCollection<C_T_beneficiaire>();
        public ObservableCollection<C_T_beneficiaire> BcpParticipants
        {
            get { return _BcpParticipants; }
            set { AssignerChamp<ObservableCollection<C_T_beneficiaire>>(ref _BcpParticipants, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        private VM_UnJoueur _UnJoueur;
        public VM_UnJoueur UnJoueur
        {
            get { return _UnJoueur; }
            set { AssignerChamp<VM_UnJoueur>(ref _UnJoueur, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        private ObservableCollection<C_T_listParticipant> _BcpJoueurs = new ObservableCollection<C_T_listParticipant>();
        public ObservableCollection<C_T_listParticipant> BcpJoueurs
        {
            get { return _BcpJoueurs; }
            set { AssignerChamp<ObservableCollection<C_T_listParticipant>>(ref _BcpJoueurs, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        #endregion

        public VM_Event()
        {
            UnEvent = new VM_UnEvent();
            UnEvent.ID = 0;
            UnEvent.Date = DateTime.Now;
            UnEvent.Description = "Description de l'événement";
            UnEvent.Duree = DateTime.Now;
            BcpEvents = ChargerEvents(chConnexion);
            BcpLieux =  ChargerLieux(chConnexion);
            BcpTypeEvents = ChargerTypeEvent(chConnexion);
            BcpEquipes = ChargerEquipes(chConnexion);
            BcpParticipants = ChargerParticipant(chConnexion);


            cAfficherJoueur = new BaseCommande(ChargerJoueur);

            ActiverUneFiche = false;
            cConfirmer = new BaseCommande(Confirmer);
            cAnnuler = new BaseCommande(Annuler);
            cAjouter = new BaseCommande(Ajouter);
            cAjouterJoueur = new BaseCommande(AjouterJoueur);
            cModifier = new BaseCommande(Modifier);
            cSupprimer = new BaseCommande(Supprimer);
            cSupprimerJoueur = new BaseCommande(SupprimerJoueur);
            cAjouterEquipe = new BaseCommande(AjouterEquipe);
            
        }

        #region Commandes
        public BaseCommande cConfirmer { get; set; }
        public BaseCommande cAnnuler { get; set; }
        public BaseCommande cAjouter { get; set; }
        public BaseCommande cAjouterJoueur { get; set; }
        public BaseCommande cModifier { get; set; }
        public BaseCommande cSupprimer { get; set; }
        public BaseCommande cSupprimerJoueur { get; set; }
        public BaseCommande cAjouterEquipe { get; set; }
        public BaseCommande cAfficherJoueur { get; set; }
        #endregion

        #region Chargement
        private ObservableCollection<C_T_event> ChargerEvents(string chConn)
        {
            ObservableCollection<C_T_event> rep = new ObservableCollection<C_T_event>();
            List<C_T_event> lTmp = new G_T_event(chConn).Lire("E_date");
            foreach (C_T_event Tmp in lTmp)
                rep.Add(Tmp);
            return rep;
        }

        private ObservableCollection<C_T_lieu> ChargerLieux(string chConn)
        {
            ObservableCollection<C_T_lieu> rep = new ObservableCollection<C_T_lieu>();
            List<C_T_lieu> lTmp = new G_T_lieu(chConn).Lire("L_nom");
            foreach (C_T_lieu Tmp in lTmp)
                rep.Add(Tmp);
            return rep;
        }

        private ObservableCollection<C_T_typeEvenement> ChargerTypeEvent(string chConn)
        {
            ObservableCollection<C_T_typeEvenement> rep = new ObservableCollection<C_T_typeEvenement>();
            List<C_T_typeEvenement> lTmp = new G_T_typeEvenement(chConn).Lire("TE_nom");
            foreach (C_T_typeEvenement Tmp in lTmp)
                rep.Add(Tmp);
            return rep;
        }

        private ObservableCollection<C_T_equipe> ChargerEquipes(string chConn)
        {
            ObservableCollection<C_T_equipe> rep = new ObservableCollection<C_T_equipe>();
            List<C_T_equipe> lTmp = new G_T_equipe(chConn).Lire("L_nom");
            foreach (C_T_equipe Tmp in lTmp)
                rep.Add(Tmp);
            return rep;
        }

        private ObservableCollection<C_T_beneficiaire> ChargerParticipant(string chConn)
        {
            ObservableCollection<C_T_beneficiaire> rep = new ObservableCollection<C_T_beneficiaire>();
            List<C_T_beneficiaire> lTmp = new G_T_beneficiaire(chConn).Lire("B_nom");
            foreach (C_T_beneficiaire Tmp in lTmp)
                rep.Add(Tmp);
            return rep;
        }

        private void ChargerJoueur()
        {
            if (EquipeSelectionnee != null)
            {
                ObservableCollection<C_T_listParticipant> rep = new ObservableCollection<C_T_listParticipant>();

                List<C_T_listParticipant> lTmp = new G_T_listParticipant(chConnexion).Lire("B_nom");
                foreach (C_T_listParticipant Tmp in lTmp)
                    if (EquipeSelectionnee.ID_equipe == Tmp.ID_equipe)
                        rep.Add(Tmp);

                BcpJoueurs = rep;
            }
        }
        #endregion

        public void Confirmer()
        {
            if (TypeEventSelectionnee != null && LieuSelectionnee != null) {
                if (nAjout == -1)
                {
                    UnEvent.ID = new G_T_event(chConnexion).Ajouter(UnEvent.Date, UnEvent.Duree, TypeEventSelectionnee.ID_typeEvenement, UnEvent.Description, LieuSelectionnee.ID_lieu, null);
                    BcpEvents.Add(new C_T_event(UnEvent.ID, UnEvent.Date, UnEvent.Duree, TypeEventSelectionnee.ID_typeEvenement, UnEvent.Description, LieuSelectionnee.ID_lieu, null));
                }
                else
                {
                    new G_T_event(chConnexion).Modifier(UnEvent.ID, UnEvent.Date, UnEvent.Duree, TypeEventSelectionnee.ID_typeEvenement, UnEvent.Description, LieuSelectionnee.ID_lieu, null);
                    BcpEvents[nAjout] = new C_T_event(UnEvent.ID, UnEvent.Date, UnEvent.Duree, TypeEventSelectionnee.ID_typeEvenement, UnEvent.Description, LieuSelectionnee.ID_lieu, null);
                }
                ActiverUneFiche = false;
            }
        }
        public void Annuler()
        { ActiverUneFiche = false; }
        public void Ajouter()
        {
            UnEvent = new VM_UnEvent();
            UnEvent.Date = DateTime.Now ;
            UnEvent.Description = "Description de l'événement" ;
            UnEvent.Duree = DateTime.Now ;
            nAjout = -1;
            ActiverUneFiche = true;
        }

        public void AjouterJoueur()
        {
            if (ParticipantSelectionnee !=null && EquipeSelectionnee != null)
            {
                UnJoueur = new VM_UnJoueur();
                UnJoueur.ID = new G_T_listParticipant(chConnexion).Ajouter(EquipeSelectionnee.ID_equipe, ParticipantSelectionnee.ID_beneficiaire);
                BcpJoueurs.Add(new C_T_listParticipant(UnJoueur.ID, EquipeSelectionnee.ID_equipe, ParticipantSelectionnee.ID_beneficiaire));
            }
        }

        public void AjouterEquipe()
        {
            if (EventSelectionnee != null && EquipeSelectionnee != null)
            {
                C_T_equipe Tmp = new G_T_equipe(chConnexion).Lire_ID(EquipeSelectionnee.ID_equipe);

                UneEquipe = new VM_UneEquipe();
                UneEquipe.ID = Tmp.ID_equipe;
                UneEquipe.Nom = Tmp.E_nom;
                UneEquipe.Point = Tmp.E_point;

                new G_T_equipe(chConnexion).Modifier(UneEquipe.ID, UneEquipe.Nom, 0, EventSelectionnee.ID_event);
                BcpEquipes[BcpEquipes.IndexOf(EquipeSelectionnee)] = new C_T_equipe(UneEquipe.ID, UneEquipe.Nom, 0, EventSelectionnee.ID_event);

            }
        }
            public void Modifier()
        {
            if (EventSelectionnee != null)
            {
                C_T_event Tmp = new G_T_event(chConnexion).Lire_ID(EventSelectionnee.ID_event);

                UnEvent = new VM_UnEvent();
                UnEvent.ID = Tmp.ID_event;
                UnEvent.Date = Tmp.E_date.Value;
                UnEvent.Description = Tmp.E_description;
                UnEvent.Duree = Tmp.E_duree.Value;
                UnEvent.ID_TypeEvent = Tmp.ID_typeEvenement.Value;
                UnEvent.ID_Lieu = Tmp.ID_lieu.Value;
                UnEvent.Img = Tmp.E_Pic;
                nAjout = BcpEvents.IndexOf(EventSelectionnee);
                ActiverUneFiche = true;
            }
        }
        public void Supprimer()
        {
            if (EventSelectionnee != null)
            {
                new G_T_event(chConnexion).Supprimer(EventSelectionnee.ID_event);
                BcpEvents.Remove(EventSelectionnee);
            }
        }
        public void SupprimerJoueur()
        {
            if (JoueurSelectionnee != null)
            {
                
                new G_T_listParticipant(chConnexion).Supprimer(JoueurSelectionnee.ID_LP);
                BcpJoueurs.Remove(JoueurSelectionnee);
            }

        }

    }
    public class VM_UnEvent : BasePropriete
    {
        private int _ID,_ID_TypeEvent,_ID_Lieu;
        private string _Description;
        private DateTime _Duree, _Date;
        private byte?[] _Img;


        public int ID
        {
            get { return _ID; }
            set { AssignerChamp<int>(ref _ID, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public string Description
        {
            get { return _Description; }
            set { AssignerChamp<string>(ref _Description, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public int ID_Lieu
        {
            get { return _ID_Lieu; }
            set { AssignerChamp<int>(ref _ID_Lieu, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public int ID_TypeEvent
        {
            get { return _ID_TypeEvent; }
            set { AssignerChamp<int>(ref _ID_TypeEvent, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public byte?[] Img
        {
            get { return _Img; }
            set { AssignerChamp<byte?[]>(ref _Img, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public DateTime Duree
        {
            get { return _Duree; }
            set { AssignerChamp<DateTime>(ref _Duree, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public DateTime Date
        {
            get { return _Date; }
            set { AssignerChamp<DateTime>(ref _Date, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
    }

    public class VM_UnJoueur : BasePropriete
    {
        private int _ID, _ID_Equipe, _ID_Beneficiaire;
        
        public int ID
        {
            get { return _ID; }
            set { AssignerChamp<int>(ref _ID, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }
        
        public int ID_Equipe
        {
            get { return _ID_Equipe; }
            set { AssignerChamp<int>(ref _ID_Equipe, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

        public int ID_Beneficiaire
        {
            get { return _ID_Beneficiaire; }
            set { AssignerChamp<int>(ref _ID_Beneficiaire, value, System.Reflection.MethodBase.GetCurrentMethod().Name); }
        }

       
    }
}