using MiniGames.Client.ViewModel;
using MiniGames.Shared.Enums;
using MiniGames.Shared.Models;
using System.Collections.Generic;
using System.Linq;
using Xunit;

namespace MiniGamesTests
{
    public class UnoTest
    {
        public Uno UnoRegeln = new();

        private KartenModel BeispielKarte(string name, string farbe, bool spezial)
        {
            var _name = name;
            var _farbe = farbe;
            var _spezial = spezial;

            KartenModel kartenModel = new()
            {
                Name = _name,
                Farbe = _farbe,
                Spezial = _spezial
            };

            return kartenModel;
        }

        private HandKartenModel BeispielHand()
        {
            HandKartenModel HandStapel = new()
            {
                Id = 1,
                Name = "Andrej",
                KartenModels = new()
                {
                    new KartenModel
                    {
                        Name = Kartenbezeichnung.PlusZweiKarte.ToString(),
                        Farbe = Farbe.Gelb.ToString(),
                        Spezial = true
                    }
                }
            };

            return HandStapel;
        }

        private StapelModel BeispielStapelModelKarten(string name, string farbe, bool spezial)
        {
            var _name = name;
            var _farbe = farbe;
            var _spezial = spezial;

            StapelModel TestStapel = new();
            TestStapel.KartenModels = new()
            {
                new KartenModel
                {
                    Name = _name,
                    Farbe = _farbe,
                    Spezial = _spezial
                },
            };
            return TestStapel;
        }


        [Theory]
        [InlineData(Farbe.Rot, Farbe.Rot, true)]
        [InlineData(Farbe.Blau, Farbe.Rot, false)]
        [InlineData(Farbe.Rot, Farbe.Blau, false)]
        [InlineData(Farbe.Blau, Farbe.Blau, true)]
        [InlineData(Farbe.Gelb, Farbe.Rot, false)]
        [InlineData(Farbe.Gruen, Farbe.Gruen, true)]
        private void IstAblageStabelFarbeGleichZuLegendeKarteTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
        {
            //arrange
            UnoRegeln.ZiehKartenStapelZusammenstellen();
            var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
            var _neueKarteFarbe = neueKarteFarbe.ToString();
            var _erwartet = erwartet;

            UnoRegeln.KartenAblageStapel.KartenModels = new();
            UnoRegeln.KartenAblageStapel.KartenModels.Add(BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false));

            //act
            var erhalten = UnoRegeln.IstAblageStabelFarbeGleichZuLegendeKarte(_neueKarteFarbe);

            //assert
            Assert.Equal(_erwartet, erhalten);
        }

        [Fact]
        private void ZiehEineKarteTest()
        {
            //arrange
            UnoRegeln.ZiehKartenStapelZusammenstellen();
            List<KartenModel> KartenListe = new();

            var beispielHand = BeispielHand();
            var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();

            //act
            KartenListe = UnoRegeln.ZiehEineKarte(beispielHand.KartenModels);

            var erhalten = KartenListe.LastOrDefault();

            //assert
            Assert.Equal(erwartet, erhalten);
        }

        [Theory]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true)]
        private void PlusZweiKarteAufStapelLegenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
        {
            //arrange
            UnoRegeln.ZiehKartenStapelZusammenstellen();
            var kartenAblageStapel = UnoRegeln.KartenAblageStapel;
            var ziehKartenStapel = UnoRegeln.ZiehKartenStapel;

            var _kartenbezeichnung = kartenbezeichnung.ToString();
            var _farbe = farbe.ToString();
            var _spezial = spezial;
            var naechstenHand = BeispielHand();
            var beispielZuLegendeKarte = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);


            //act
            naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);

            //assert
        }

        #region Stapel erstellen
        [Theory]
        [InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
        [InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
        [InlineData((Kartenbezeichnung)9, Farbe.Gruen, false, 19)]
        [InlineData((Kartenbezeichnung)4, Farbe.Rot, false, 19)]
        [InlineData((Kartenbezeichnung)5, Farbe.Blau, false, 19)]
        [InlineData((Kartenbezeichnung)9, Farbe.Gelb, false, 19)]
        [InlineData((Kartenbezeichnung)6, Farbe.Gruen, false, 19)]
        private void ErstelleStandardKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
        {
            //arrange
            var _kartenbezeichnung = kartenbezeichnung.ToString();
            var _farbe = farbe.ToString();
            var _spezial = spezial;
            var _anzahl = anzahl;
            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

            //act
            var neuesDeck = Uno.ErstelleStandardKarten();
            var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
            var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
            var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
            var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();

            //assert           
            Assert.Equal(_anzahl, anzahlBlau);
            Assert.Equal(_anzahl, anzahlRot);
            Assert.Equal(_anzahl, anzahlGruen);
            Assert.Equal(_anzahl, anzahlGelb);

            Assert.Contains(neuesDeck.KartenModels, n =>
                n.Name.Equals(erwartet.Name) &&
                n.Farbe.Equals(erwartet.Farbe) &&
                n.Spezial == erwartet.Spezial
            );
        }

        [Theory]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true, 6)]
        [InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Rot, true, 6)]
        [InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gelb, true, 6)]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Blau, true, 6)]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gruen, true, 6)]
        [InlineData(Kartenbezeichnung.RetoureKarte, Farbe.Gelb, true, 6)]
        [InlineData(Kartenbezeichnung.AussetzenKarte, Farbe.Gruen, true, 6)]
        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Rot, true, 6)]
        private void ErstelleFarbigeSpezialKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
        {
            //arrange
            var _kartenbezeichnung = kartenbezeichnung.ToString();
            var _farbe = farbe.ToString();
            var _spezial = spezial;
            var _anzahl = anzahl;
            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

            //act
            var neuesDeck = Uno.ErstelleFarbigeSpezialKarten();
            var anzahlBlau = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Blau.ToString())).Count();
            var anzahlRot = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Rot.ToString())).Count();
            var anzahlGruen = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gruen.ToString())).Count();
            var anzahlGelb = neuesDeck.KartenModels.Where(x => x.Farbe.Equals(Farbe.Gelb.ToString())).Count();


            //assert
            Assert.Equal(_anzahl, anzahlBlau);
            Assert.Equal(_anzahl, anzahlRot);
            Assert.Equal(_anzahl, anzahlGruen);
            Assert.Equal(_anzahl, anzahlGelb);

            Assert.Contains(neuesDeck.KartenModels, n =>
                n.Name.Equals(erwartet.Name) &&
                n.Farbe.Equals(erwartet.Farbe) &&
                n.Spezial == erwartet.Spezial
            );
        }

        [Theory]
        [InlineData(Kartenbezeichnung.FarbwahlKarte, Farbe.Keine, true, 4)]
        [InlineData(Kartenbezeichnung.ZiehVierFarbenwahlkarte, Farbe.Keine, true, 4)]
        private void ErstelleJokerKartenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial, int anzahl)
        {
            //arrange
            var _kartenbezeichnung = kartenbezeichnung.ToString();
            var _farbe = farbe.ToString();
            var _spezial = spezial;
            var _anzahl = anzahl;
            var erwartet = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);

            //act
            var neuesDeck = Uno.ErstelleJokerKarten();
            var ergebnisAnzahl = neuesDeck.KartenModels.Where(x => x.Name.Equals(kartenbezeichnung.ToString())).Count();

            //assert
            Assert.Equal(_anzahl, ergebnisAnzahl);
            Assert.Contains(neuesDeck.KartenModels, n =>
                n.Name.Equals(erwartet.Name) &&
                n.Farbe.Equals(erwartet.Farbe) &&
                n.Spezial == erwartet.Spezial
            );
        }

        [Fact]
        private void AblagestapelZusammenstellenTest()
        {

            UnoRegeln.ZiehKartenStapelZusammenstellen();

            var ergebnis = UnoRegeln.ZiehKartenStapel;

            Assert.Equal(108, ergebnis.KartenModels.Count());
        }

        #endregion
    }
}