using NUnit.Framework;
using System;
using System.Collections.Generic;

namespace Tests
{
    public class ExtendedDatabaseTests
    {
        private Person pesho;
        private Person gosho;
        private Person[] persons;
        private ExtendedDatabase database;
        [SetUp]
        public void Setup()
        {
            pesho = new Person(2130931, "Pesho");
            gosho = new Person(1320109, "Gosho");
        }

        [Test]
        public void TestIfPersonIsCreatedSuccessfully()
        {
            string userName = "Pesho";
            long id = 23912390120;
            Person person = new Person(id, userName);

            Assert.AreEqual(userName, person.UserName);
            Assert.AreEqual(id, person.Id);
        }

        [Test]
        public void TestIfIsInitialized()
        {
            Assert.AreNotEqual(null, this.database);
        }

        [Test]
        public void TestIfCountIncreases()
        {
            this.persons = new Person[] { pesho, gosho };
            int expectedCount = 2;
            Assert.AreEqual(expectedCount, persons.Length);
        }

        [Test]
        public void TestIfAddThrowsExceptionWhenElementsGoOverCapacity()
        {
            this.persons = new Person[17];

            Assert.Throws<ArgumentException>(() =>
            {
                this.database = new ExtendedDatabase(this.persons);
            });
        }
        [Test]
        public void TestIfAddThrowsExceptionWhenItHasTwoPeopleWithTheSameUserName()
        {
            Person newPerson = new Person(21312312, "Pesho");
            this.persons = new Person[] { pesho, gosho, newPerson };
            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database = new ExtendedDatabase(persons);
            });
        }

        [Test]
        public void TestIfAddThrowsExceptionWhenItHasPeopleWithTheSameId()
        {
            Person newPerson = new Person(1320109, "Pesho");
            this.persons = new Person[] { pesho, gosho, newPerson };

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database = new ExtendedDatabase(persons);
            });
        }

        [Test]
        public void TestIfRemoveDoesntExecuteEmptyCollection()
        {
            this.persons = new Person[] { };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.Remove();
            });
        }
        [Test]
        public void TestIfRemoveThrowsExceptionWhenCollectionBecomesEmpty()
        {
            this.persons = new Person[] { pesho, gosho };
            this.database = new ExtendedDatabase(persons);

            this.database.Remove();
            this.database.Remove();

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.Remove();
            });
        }
        [Test]
        public void TestIfItThrowsExceptionWhenCountReaches16()
        {
            this.persons = new Person[] { pesho, gosho, new Person(213124, "Ivan"), new Person(2166124, "sss"), new Person(90345834, "asdsa"), new Person(123456677, "azsum"), new Person(131243, "tozi"), new Person(8888888, "koito"), new Person(6960606, "vie"), new Person(230943809423234, "ne"), new Person(090909090909, "sadsadsadqwewq"), new Person(974761236123884, "Ivagxfn"), new Person(23043444444, "asdlksajdklsaWW"), new Person(213333344444, "omg"), new Person(300020209, "stammme"), new Person(3055032, "forthelast") };

            this.database = new ExtendedDatabase(persons);

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.Add(new Person(0923401, "yeet"));
            });
        }
        [Test]
        public void TestIfRemoveDecreasesCount()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);
            this.database.Remove();
            int expectedCount = 1;

            Assert.AreEqual(expectedCount, this.database.Count);
        }

        [TestCase(null)]
        [TestCase("")]
        public void TestIfFindByUsernameThrowsExceptionWithNullOrEmptyValues(string name)
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<ArgumentNullException>(() =>
            {
                this.database.FindByUsername(name);
            });
        }

        [Test]
        public void TestIfFindByUsernameThrowsExceptionWhenUsernameIsNotPresent()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.FindByUsername("Ivan");
            });
        }
        [Test]
        public void TestIfFindByUsernameReturnsCorrectPerson()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Person expectedPerson = pesho;
            Person actualPerson = this.database.FindByUsername("Pesho");

            Assert.AreEqual(expectedPerson, actualPerson);
        }
        [Test]
        public void FindByUsernameIsCaseSensitive()
        {
            this.persons = new Person[] { pesho, gosho };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.FindByUsername("GOSHO");
            });
        }
        [Test]
        public void TestIfFindByIdThrowsExceptionWithNegativeValue()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
                this.database.FindById(-2312321);
            });
        }

        [Test]
        public void TestIfFindByIdThrowsExceptionWhenItDoesntContainId()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Assert.Throws<InvalidOperationException>(() =>
            {
                this.database.FindById(213213123131232123);
            });
        }

        [Test]
        public void TestIfFindByIdReturnsCorrectPerson()
        {
            this.persons = new Person[] { gosho, pesho };
            this.database = new ExtendedDatabase(persons);

            Person expectedPerson = pesho;
            Person actualPerson = this.database.FindById(2130931);

            Assert.AreEqual(expectedPerson, actualPerson);
        }
    }
}