using MiniGames.Client.ViewModel;
using MiniGames.Shared.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xunit;

namespace MiniGamesTests
{
    public class SchereSteinPapierEchseSpockTest
    {
        SchereSteinPapierEchseSpock Spiel = new();
        SchereSteinPapierEchseSpockModel SpieleModel = new();
        private const string stein = "Stein";
        private const string schere = "Schere";
        private const string papier = "Papier";
        private const string echse = "Echse";
        private const string spock = "Spock";

        private const string gewonnen = "Gewonnen";
        private const string verloren = "Verloren";
        private const string unentschieden = "Unentschieden";

        private void GetSampleModels()
        {
            SpieleModel.SpielerListe = new()
            {
                new SpielerModel
                {
                    SpielerName = "Andrej",
                    Punkte = 0
                },

                new SpielerModel
                {
                    SpielerName = "CPU",
                    Punkte = 0
                }
            };
        }

        [Theory]
        [InlineData(stein, stein, unentschieden)]
        [InlineData(stein, schere, gewonnen)]
        [InlineData(stein, papier, verloren)]
        [InlineData(stein, echse, gewonnen)]
        [InlineData(stein, spock, verloren)]
        public void IsStone(string hand, string gegner, string erwartet)
        {
            //arrange
            string spielerHand = hand;
            string gegnerHand = gegner;
            string erwartetesErg = erwartet;

            //act
            string getestetesErg = Spiel.SpielerStein(spielerHand, gegnerHand);

            //assert
            Assert.Equal(erwartetesErg, getestetesErg);
        }

        [Theory]
        [InlineData(schere, stein, verloren)]
        [InlineData(schere, schere, unentschieden)]
        [InlineData(schere, papier, gewonnen)]
        [InlineData(schere, echse, gewonnen)]
        [InlineData(schere, spock, verloren)]
        public void IsScissor(string hand, string gegner, string erwartet)
        {
            //arrange
            string spielerHand = hand;
            string gegnerHand = gegner;
            string erwartetesErg = erwartet;

            //act
            string getestetesErg = Spiel.SpielerSchere(spielerHand, gegnerHand);

            //assert
            Assert.Equal(erwartetesErg, getestetesErg);
        }

        [Theory]
        [InlineData(papier, stein, gewonnen)]
        [InlineData(papier, schere, verloren)]
        [InlineData(papier, papier, unentschieden)]
        [InlineData(papier, echse, verloren)]
        [InlineData(papier, spock, gewonnen)]
        public void IsPaper(string hand, string gegner, string erwartet)
        {
            //arrange
            string spielerHand = hand;
            string gegnerHand = gegner;
            string erwartetesErg = erwartet;

            //act
            string getestetesErg = Spiel.SpielerPapier(spielerHand, gegnerHand);

            //assert
            Assert.Equal(erwartetesErg, getestetesErg);
        }

        [Theory]
        [InlineData(echse, stein, verloren)]
        [InlineData(echse, schere, verloren)]
        [InlineData(echse, papier, gewonnen)]
        [InlineData(echse, echse, unentschieden)]
        [InlineData(echse, spock, gewonnen)]
        public void IsLizard(string hand, string gegner, string erwartet)
        {
            //arrange
            string spielerHand = hand;
            string gegnerHand = gegner;
            string erwartetesErg = erwartet;

            //act
            string getestetesErg = Spiel.SpielerEchse(spielerHand, gegnerHand);

            //assert
            Assert.Equal(erwartetesErg, getestetesErg);
        }

        [Theory]
        [InlineData(spock, stein, gewonnen)]
        [InlineData(spock, schere, gewonnen)]
        [InlineData(spock, papier, verloren)]
        [InlineData(spock, echse, verloren)]
        [InlineData(spock, spock, unentschieden)]
        public void IsSpock(string hand, string gegner, string erwartet)
        {
            //arrange
            string spielerHand = hand;
            string gegnerHand = gegner;
            string erwartetesErg = erwartet;

            //act
            string getestetesErg = Spiel.SpielerSpock(spielerHand, gegnerHand);

            //assert
            Assert.Equal(erwartetesErg, getestetesErg);
        }

        [Theory]
        [InlineData(0, stein)]
        [InlineData(1, schere)]
        [InlineData(2, papier)]
        [InlineData(3, echse)]
        [InlineData(4, spock)]
        public void PChand(int index, string erwartet)
        {
            //arrange
            int _index = index;
            string _erwartet = erwartet;

            //act
            string erg = Spiel.CPUHand(_index);

            //assert
            Assert.Equal(_erwartet, erg);
        }
    
        [Theory]
        [InlineData(0, 1, gewonnen)]
        [InlineData(0, 0, verloren)]
        [InlineData(1, 1, verloren)]
        [InlineData(1, 0, gewonnen)]
        public void ErgebnisBerechnungTest(int player, int punkte, string ergebnis)
        {
            GetSampleModels();
            //arrange
            int _player = player;
            int _punkte = punkte;
            string _ergebnis = ergebnis;

            //act
            SchereSteinPapierEchseSpockModel endPunktzahl = SchereSteinPapierEchseSpock.PunkteBerechnung(SpieleModel, _ergebnis);

            //assert
            Assert.Equal(_punkte, endPunktzahl.SpielerListe[_player].Punkte);
        }
    }
}