using MiniGames.Client.ViewModel;
using MiniGames.Shared.Models;
using Xunit;

namespace MiniGamesTests
{
    public class TicTacToeTest
    {
        TicTacToeBrett StandardBrett()
        {
            return new TicTacToeBrett();
        }

        SpielerModel[] StandardSpieler()
        {
            return new SpielerModel[]
            {
                new SpielerModel
                {
                    SpielerName = "Spieler 1",
                    Punkte = 0
                },
                new SpielerModel
                {
                    SpielerName = "Spieler 2",
                    Punkte = 1
                }
            };
        }

        TicTacToeModel StandardModel()
        {
            return new TicTacToeModel
            {
                Spieler = StandardSpieler(),
                Brett = StandardBrett(),
            };
        }

        TicTacToe StandardSpiel()
        {
            return new(StandardModel());
        }

        [Theory]
        [InlineData(0, 1)]
        [InlineData(1, 0)]
        public void SpielerWechselTest(int vorher, int nachher)
        {
            // arrange
            TicTacToe spiel = StandardSpiel();
            spiel.AktiverSpielerIndex = vorher;
            int erwarteterIndex = nachher;

            // act
            spiel.SpielerWechsel();

            // assert
            Assert.Equal(erwarteterIndex, spiel.AktiverSpielerIndex);
        }

        [Fact]
        public void SpielerInput_ValidesInputTest()
        {
            // arrange
            TicTacToe spiel = StandardSpiel();
            spiel.AktiverSpielerIndex = 0;
            int erwarteterSpielerIndex = 1;

            int pos = 2;
            TicTacToeBrett erwartetesBrett = new(new int[,]
            {
                { TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
                { TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
                { spiel.AktiverSpielerIndex, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
            });

            // act
            spiel.SpielerInput(pos);

            // assert
            Assert.True(spiel.Brett.Gleich(erwartetesBrett));
            Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
        }

        [Fact]
        public void SpielerInput_InvalidesInputTest()
        {
            // arrange
            TicTacToe spiel = StandardSpiel();
            spiel.AktiverSpielerIndex = 0;
            int erwarteterSpielerIndex = 0;

            int pos = -1;
            TicTacToeBrett erwartetesBrett = StandardBrett();

            // act
            spiel.SpielerInput(pos);

            // assert
            Assert.True(spiel.Brett.Gleich(erwartetesBrett));
            Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
        }

        [Theory]
        [InlineData(0, 0, 3, 1, 4, 2)]
        [InlineData(0, 3, 0, 4, 1, 5, 2)]
        [InlineData(1, 0, 6, 3, 4, 6, 1, 2)]
        public void SpielerInput_GewinnerTest(int gewinnerIndex, params int[] inputs)
        {
            // arrange
            TicTacToe spiel = StandardSpiel();
            spiel.AktiverSpielerIndex = 0;
            spiel.Spieler[0].Punkte = 0;
            spiel.Spieler[1].Punkte = 1;
            int erwartetePunkteSpieler1 = (gewinnerIndex == 0) ? 1 : 0;
            int erwartetePunkteSpieler2 = (gewinnerIndex == 1) ? 2 : 1;
            int erwarteterGewinnerIndex = gewinnerIndex;

            // act
            foreach (int input in inputs)
            {
                spiel.SpielerInput(input);
            }

            // assert
            Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
            Assert.Equal(spiel.Spieler[0].Punkte, erwartetePunkteSpieler1);
            Assert.Equal(spiel.Spieler[1].Punkte, erwartetePunkteSpieler2);
        }

        [Fact]
        public void SpielerInput_KeinGewinnerTest()
        {
            // arrange
            TicTacToe spiel = StandardSpiel();
            spiel.AktiverSpielerIndex = 0;
            spiel.Spieler[0].Punkte = 0;
            spiel.Spieler[1].Punkte = 0;
            int erwartetePunkteSpieler1 = 0;
            int erwartetePunkteSpieler2 = 0;
            int erwarteterGewinnerIndex = -1;

            // act
            spiel.SpielerInput(0);
            spiel.SpielerInput(3);
            spiel.SpielerInput(1);
            spiel.SpielerInput(4);
            spiel.SpielerInput(5);
            spiel.SpielerInput(2);

            // assert
            Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
            Assert.Equal(spiel.Spieler[0].Punkte, erwartetePunkteSpieler1);
            Assert.Equal(spiel.Spieler[1].Punkte, erwartetePunkteSpieler2);
        }
    }
}