asdfdsf

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Text;
using System.ComponentModel;

namespace Dominio
{
    public abstract class Partido
    {
        #region Atributos
        private List<Incidencia> _incidencias = new List<Incidencia>();
        private int _id;
        private static int s_ultId;
        private DateTime _fechaHora;
        private bool _finalizado = false;
        private string _resultado = "Pendiente";
        private Seleccion _seleccionA;
        private Seleccion _seleccionB;
        private Seleccion _seleccionGanadora;
        private bool _empate;
        #endregion

        #region Properties
        public List<Incidencia> Incidencias { get => _incidencias; set => _incidencias = value; }
        public int Id { get => _id; set => _id = value; }
        public DateTime FechaHora { get => _fechaHora; set => _fechaHora = value; }
        public bool Finalizado { get => _finalizado; set => _finalizado = value; }
        public string Resultado { get => _resultado; set => _resultado = value; }
        public Seleccion SeleccionGanadora { get => _seleccionGanadora; set => _seleccionGanadora = value; }
        public bool Empate { get => _empate; set => _empate = value; }
        public Seleccion SeleccionA { get => _seleccionA; set => _seleccionA = value; }
        public Seleccion SeleccionB { get => _seleccionB; set => _seleccionB = value; }
        #endregion

        #region Constructor
        public Partido(DateTime fechaHora, bool finalizado, string resultado, Seleccion seleccionA, Seleccion seleccionB, bool empate)
        {
            _fechaHora = fechaHora;
            _finalizado = finalizado;
            _resultado = resultado;
            _seleccionA = seleccionA;
            _seleccionB = seleccionB;
            //_ganador = ganador;
            _empate = empate;
            _id = Partido.s_ultId;
            Partido.s_ultId++;
        }
        #endregion


        public abstract string ObtenerNombreFase();

        #region Validaciones
        public void Validar()
        {
            //Validar fechas del partido
            if (_fechaHora < DateTime.Parse("2022-11-20") || _fechaHora > DateTime.Parse("2022-12-18"))
            {
                throw new Exception("La fecha del partido debe ser entre 2022/11/20 y 2022/12/18");

            }
            if (_seleccionA == _seleccionB)
            {
                throw new Exception("Las Selecciones no pueden ser las mismas");
            }
            //if(_incidencias.)
        }
        #endregion

        #region Incidencias
        //Crea nueva incidencia
        public void RegistrarIncidencia(Incidencia nuevaIncidencia)
        {
            //Registrar incidencia solo si el partido no ha finalizado
            if (!_finalizado)
            {
                try
                {
                    nuevaIncidencia.Validar(SeleccionA, SeleccionB);
                    if (!_incidencias.Contains(nuevaIncidencia))
                    {
                        _incidencias.Add(nuevaIncidencia);
                    }
                }
                catch (NullReferenceException ex)
                {
                    Console.WriteLine("\n" + ex.Message + "\n");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("\n" + ex.Message + "\n");
                }
            }
        }

        //Ordenar incidencias por minuto
        public List<Incidencia> IncidenciasOrdenadas()
        {
            _incidencias.Sort();
            return _incidencias;
        }
        #endregion


        #region Funciones Partido TESTING



        public bool JugadorExpulsado()
        {
            return false;
        }

        public List<Jugador> JugadoresDePartido()
        {
            List<Jugador> jugadoresDelPartido = _seleccionA.Jugadores;
            jugadoresDelPartido.AddRange(_seleccionB.Jugadores);
            return jugadoresDelPartido;
        }

        public bool JugadorExpulsado(Jugador j)
        {
            bool expulsado = false;
            int cantAmarillas = 0;
            foreach (Incidencia i in _incidencias)
            {
                if (i.Jugador.Equals(j) && i.TipoIncidencia is TipoIncidencia.tarjetaRoja)
                {
                    expulsado = true;
                }
                if (i.Jugador.Equals(j) && i.TipoIncidencia is TipoIncidencia.tarjetaAmarilla)
                {
                    cantAmarillas++;
                }
            }
            if (cantAmarillas == 2)
            {
                expulsado = true;
            }

            return expulsado;
        }
        #endregion


        #region Funciones Partido


        //Recibe un jugador y una lista de incidencias y devuelve la cantidad de incidencias de un jugador
        public int CantidadTipoIncidenciaJugador(Jugador j, List<Incidencia> incidencias)
        {
            int cantidad = 0;
            foreach (Incidencia i in incidencias)
            {
                if ((i.Jugador.Id == j.Id))
                {
                    cantidad++;
                }
            }
            return cantidad;
        }

        //Devuelve cantidad de goles por partido de la seleccion
        public int CantidadTipoIncidenciaPartido(Seleccion seleccion, List<Incidencia> incidencias)
        {
            int cantidad = 0;
            foreach (Incidencia i in incidencias)
            {
                if ((i.Jugador.Pais.Nombre == seleccion.Paises.Nombre))
                {
                    cantidad++;
                }
            }
            return cantidad;
        }
        #endregion

        public int CantidadIncidenciaPartido(Seleccion seleccion, string tipo)
        {
            int cantidad = 0;
            foreach (Incidencia i in _incidencias)
            {
                if (seleccion == SeleccionA && (string)i.TipoIncidencia.ToString() == tipo)
                {
                    cantidad++;
                }
            }
            return cantidad;
        }


        #region Ordenamiento
        #endregion




        #region z
        //Determinar Empate
        public void HayEmpate()
        {
            if (_resultado == "Empate")
            {
                _empate = true;
            }
        }

        public string TextoEmpate(bool empate)
        {
            string result = "";
            if (empate)
            {
                result = "Partido empatado";
            }
            else
            {
                result = "No hubo empate";
            }
            return result;
        }
        public string TextoFinalizado()
        {
            string result = "";
            if (_finalizado)
            {
                result = "Finalizado";
            }
            else
            {
                result = "Pendiente";
            }

            return result;
        }
        //EN PROCESO



        #region Polimorfismo
        public virtual void FinalizarPartido()
        {
            _finalizado = true;
        }


        public virtual string CalcularGanador()
        {
            //if partido termino di
            string r = "";
            //Codigo
            int golesA = CantidadTipoIncidenciaSeleccion(SeleccionA, TipoIncidencia.gol);
            int golesB = CantidadTipoIncidenciaSeleccion(SeleccionB, TipoIncidencia.gol);

            if (golesA > golesB)
            {
                r += "Ganador: " + SeleccionA.Paises.Nombre + "\n";
            }
            if (golesA < golesB)
            {
                r += "Ganador: " + SeleccionB.Paises.Nombre + "\n";
            }
            if (golesA == golesB)
            {
                _empate = true;
                r += "\nEmpate" + "\n";
            }
            return r;
        }
        #endregion

        //public abstract string CalcularGanador();

        //TESTING

        /*
        public virtual string CalcularResultado()
        {
            if (_finalizado)
            {
                //CalcularGanador
                if (!_empate)
                {
                    _resultado = "El ganador es " + CalcularResultado() + "\n";
                }
                else if (_empate)
                {
                    _resultado = "Empate" + "\n";
                }
            }
            return _resultado;
        }
        */



        //Recib seleccion y tipo de incidencia, Devuelve cantidad del tipo de incidencia de la seleccion en el aprtido
        public int CantidadTipoIncidenciaSeleccion(Seleccion miSelecion, TipoIncidencia tipoIncidencia)
        {
            int incidencias = 0;
            foreach (Jugador miJugador in miSelecion.Jugadores)
            {
                if (miSelecion.Jugadores.Contains(miJugador))
                {
                    incidencias += CantIncidenciasJugador(miJugador, tipoIncidencia);
                }
            }
            return incidencias;
        }
        //Recibe un jugador y una lista de incidencias y devuelve la cantidad de incidencias de un jugador
        public int CantIncidenciasJugador(Jugador miJugador, TipoIncidencia tipoIncidencia)
        {
            int cantidad = 0;
            foreach (Incidencia miIncidencia in this._incidencias)
            {
                if ((miIncidencia.Jugador.Id == miJugador.Id) && miIncidencia.TipoIncidencia.Equals(tipoIncidencia))
                {
                    cantidad++;
                }
            }
            return cantidad;
        }
        // END INCIDENCIAS OBL2












        //TESTING

        public bool HayGanador()
        {
            bool hayGanador = true;
            //Codigo
            return hayGanador;
        }

        public void CrearPartido()
        {

        }
        #endregion


        #region ToString
        public override string ToString()
        {
            return
                "Id: " + this._id + "\n" +
                "Fecha: " + this.FechaHora + "\n" +
                this.SeleccionA.Paises.Nombre + " vs " + "\n" +
                this.SeleccionB.Paises.Nombre + "\n" +
                "Finalizado: " + this.TextoFinalizado() + "\n" +
                "Resultado: " + this._resultado + "\n" +
                "" + this.TextoEmpate(Empate) + "\n" +
                "Incidencias: " + "\n" +
               this.MostrarIncidenciasPartido() + "\n";
        }
        //Se invoca partido.MostrarIncidenciasPartido y devuelve la lista de incidencias asociadas
        //Se usa para listar todos los partidos
        //Para ToString
        public string MostrarIncidenciasPartido()
        {
            string r = "";
            foreach (Incidencia miIncidencia in _incidencias)
            {

                r +=
                     "* " + miIncidencia.IncidenciaString(miIncidencia.TipoIncidencia) + ", " +
                    "" + miIncidencia.Jugador.NombreCompleto + ", " +
                    "minuto " + miIncidencia.Minuto + "\n";
            }
            return r;
        }


        #endregion

        /*
         * Recibe un jugador y devuelve las incidencias
         * del partido segun se pide en fase eliminatoria
         * 
         * OBSOLETO, Es mejor recorrer desde la vista y tener control sobre el HTML
         */
        //Hay que recorre ne la vista, esta generando saltos de linea en blanco
        /*
        public string IncidenciasJugador(Jugador j)
        {
            string r = "";
            foreach(Incidencia i in _incidencias)
            {
                if(i.Jugador.Equals(j)) {
                    r += i.IncidenciasEliminatoriasDeJugador(j);
                }
            }
            return r;
        }

        public List<Incidencia> IncidenciasOrdenadas()
        {
            _incidencias.Sort();
            return _incidencias;
        }
        */



        public List<Incidencia> CantidadIncidenciasDePartido(
            TipoIncidencia miTipoIncidencia)
        {
            List<Incidencia> incidenciasPartido = new List<Incidencia>();
            foreach (Incidencia i in _incidencias)
            {
                if (i.TipoIncidencia.Equals(miTipoIncidencia))
                {
                    if (!incidenciasPartido.Contains(i))
                    {
                        incidenciasPartido.Add(i);
                    }
                }
            }
            return incidenciasPartido;
        }




























        //EST PODRIA IR EN AGENCIA
        //Recibe un patido y una lista de incidencias, devuelve lista de incidencias del partido solo del tipo solicitado
        //(filtra)
        /*

        /*




        /*  OBSOLETO
        //DEvuelve cantidad por partido no por seleccion
        public int CantidadTipoIncidenciaSeleccion(Seleccion miSeleccion, string tipo)
        {
            int cantidad = 0;
            foreach (Incidencia i in _incidencias)
            {
                if (SeleccionA==miSeleccion && (string)i.TipoIncidencia.ToString() == tipo)
                {
                    cantidad++;
                }
            }
            return cantidad;
        }
        */


        /*
         * Recibe una lista de jugadores de seleccion por medio del metodo
         * SeleccionN.Jugadores (Filtro)
         * Llama para cada uno de esos jugadores a la funcion que devuelve
         * la informacion de cada incidencia que cometio
         * 
         * OBSOLETO
         * Se filtra la seleccion desde la vista en Model.SeleccionN.Jugadores
         * Al ya tener la lista de jugadores de la seleccion a o b en el partido
         * solo queda obtener las incidencias del mismo
         * 
         */
        //PAsamos la lista entrera de la selecion
        /* OBSOLETO
        public string IncidenciasEliminatoriasDeSeleccion(List<Jugador> jugadoresDeSeleccion)
        {
            string r = "";
            foreach (Jugador jugador in jugadoresDeSeleccion)
            {
                r += IncidenciasJugador(jugador);
            }
            return r;
        }
        */






        //Ver si sustituir
        /*
        public string IncidenciaFoereaachView(Seleccion sel)
        {
            string r = "";
            foreach(Incidencia i in IncidenciasOrdenadas())
            {
                if (sel.Jugadores.Contains(i.Jugador))
                {
                    r+= i.IncidenciasEliminatoriasDeJugador(i.Jugador);
                }
            }
            return r;
        }
        */

        /* idea no usada ver
        public List<Incidencia> ListaIncidenciasJugador(Jugador j)
        {
            List<Incidencia> l = new List<Incidencia>();
            foreach (Incidencia i in _incidencias)
            {
                if (i.Jugador.Equals(j))
                {
                    l.Add(i);
                }
            }
            return l;
        }
        */




    }
}