// Author: Gockner, Simon
// Created: 2020-02-12
// Copyright(c) 2020 SimonG. All Rights Reserved.

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using GBase.DataHandling;
using GBase.DataHandling.Cache.Factories;
using GBase.DataHandling.Factories;
using GBase.Interfaces.DataHandling.Xml;
using GBase.Interfaces.DataHandling.Xml.Cache;
using Moq;
using NUnit.Framework;

namespace Test.GBase.DataHandling
{
    [TestFixture]
    public class XmlDataHandlerTest
    {
        [Test]
        public async Task TestInit()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            xmlDataReaderMock.Setup(r => r.Init(It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            xmlDataWriterMock.Setup(w => w.InitFile(TODO, TODO, It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            Assert.True(await xmlDataHandler.Init(false, CancellationToken.None));
        }

        [Test]
        public async Task TestInitFailedTriedTwice()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            xmlDataReaderMock.Setup(r => r.Init(It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            xmlDataWriterMock.Setup(w => w.InitFile(TODO, TODO, It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            Assert.True(await xmlDataHandler.Init(false, CancellationToken.None));
            Assert.False(await xmlDataHandler.Init(false, CancellationToken.None));
        }

        [Test]
        public async Task TestInitFailedInitReaderFailed()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            xmlDataReaderMock.Setup(r => r.Init(It.IsAny<CancellationToken>())).ReturnsAsync(false);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            xmlDataWriterMock.Setup(w => w.InitFile(TODO, TODO, It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            Assert.False(await xmlDataHandler.Init(false, CancellationToken.None));
        }

        [Test]
        public async Task TestInitFailedInitWriterFailed()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            xmlDataReaderMock.Setup(r => r.Init(It.IsAny<CancellationToken>())).ReturnsAsync(true);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            xmlDataWriterMock.Setup(w => w.InitFile(TODO, TODO, It.IsAny<CancellationToken>())).ReturnsAsync(false);

            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            Assert.False(await xmlDataHandler.Init(false, CancellationToken.None));
        }

        [Test]
        public async Task TestSetValue()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            await xmlDataHandler.SetValue<XmlDataHandlerTest, string>(TODO, "property", "SomeString", TODO);

            xmlDataHandlerCacheMock.Verify(c => c.SetValue<XmlDataHandlerTest, string>("property", "SomeString", false), Times.Once);
            xmlDataWriterMock.Verify(w => w.Write<XmlDataHandlerTest, string>(TODO, "property", "SomeString", TODO, false, TODO), Times.Once);
        }

        [Test]
        public async Task TestSetValueList()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            List<string> stringList = new List<string>() {"string", "secondString", "thirdString"};
            await xmlDataHandler.SetValue<XmlDataHandlerTest, List<string>>(TODO, "property", stringList, TODO);

            xmlDataHandlerCacheMock.Verify(c => c.SetValue<XmlDataHandlerTest, List<string>>("property", stringList, false), Times.Once);
            xmlDataWriterMock.Verify(w => w.Write<XmlDataHandlerTest, List<string>>(TODO, "property", $"{stringList[0]},{stringList[1]},{stringList[2]}", TODO, false, TODO), Times.Once);
        }

        [Test]
        public async Task TestSetValueNull()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            await xmlDataHandler.SetValue<XmlDataHandlerTest, string>(TODO, "property", null, TODO);

            xmlDataHandlerCacheMock.Verify(c => c.SetValue<It.IsValueType, It.IsValueType>(It.IsAny<string>(), It.IsAny<It.IsValueType>(), It.IsAny<bool>()), Times.Never);
            xmlDataWriterMock.Verify(w => w.Write<It.IsValueType, It.IsValueType>(TODO, It.IsAny<string>(), It.IsAny<string>(), TODO, It.IsAny<bool>(), TODO), Times.Never);
        }

        [Test]
        public async Task TestRemoveValue()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            await xmlDataHandler.RemoveValue<XmlDataHandlerTest, string>(TODO, "property", "SomeString", TODO);

            xmlDataHandlerCacheMock.Verify(c => c.TryRemoveValue<XmlDataHandlerTest, string>("property", "SomeString"), Times.Once);
            xmlDataWriterMock.Verify(w => w.Remove<XmlDataHandlerTest, string>(TODO, "property", "SomeString", TODO), Times.Once);
        }

        [Test]
        public async Task TestRemoveValueList()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            List<string> stringList = new List<string>() { "string", "secondString", "thirdString" };
            await xmlDataHandler.RemoveValue<XmlDataHandlerTest, List<string>>(TODO, "property", stringList, TODO);

            xmlDataHandlerCacheMock.Verify(c => c.TryRemoveValue<XmlDataHandlerTest, List<string>>("property", stringList), Times.Once);
            xmlDataWriterMock.Verify(w => w.Remove<XmlDataHandlerTest, List<string>>(TODO, "property", $"{stringList[0]},{stringList[1]},{stringList[2]}", TODO), Times.Once);
        }

        [Test]
        public async Task TestRemoveValueNull()
        {
            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            await xmlDataHandler.RemoveValue<XmlDataHandlerTest, string>(TODO, "property", null, TODO);

            xmlDataHandlerCacheMock.Verify(c => c.TryRemoveValue<It.IsValueType, It.IsValueType>(It.IsAny<string>(), It.IsAny<It.IsValueType>()), Times.Never);
            xmlDataWriterMock.Verify(w => w.Remove<It.IsValueType, It.IsValueType>(TODO, It.IsAny<string>(), It.IsAny<string>(), TODO), Times.Never);
        }

        [Test]
        public void TestGetValue()
        {
            List<string> values = new List<string>() { "SomeString", "AnotherString" };

            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            //xmlDataReaderMock.Setup(r => r.Read<XmlDataHandlerTest, string>("property")).ReturnsAsync<List<string>>(values);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);
        }

        [Test]
        public async Task TestGetListValue()
        {
            List<string> values = new List<string>() { "SomeString", "AnotherString" };

            Mock<IXmlDataReader> xmlDataReaderMock = new Mock<IXmlDataReader>();
            //xmlDataReaderMock.Setup(r => r.Read<XmlDataHandlerTest, string>("property")).ReturnsAsync<List<string>>(values);

            Mock<IXmlDataReaderFactory> xmlDataReaderFactoryMock = new Mock<IXmlDataReaderFactory>();
            xmlDataReaderFactoryMock.Setup(r => r.Create(It.IsAny<string>())).Returns(xmlDataReaderMock.Object);

            Mock<IXmlDataWriter> xmlDataWriterMock = new Mock<IXmlDataWriter>();
            Mock<IXmlDataWriterFactory> xmlDataWriterFactoryMock = new Mock<IXmlDataWriterFactory>();
            xmlDataWriterFactoryMock.Setup(w => w.Create()).Returns(xmlDataWriterMock.Object);

            Mock<IXmlDataHandlerCache> xmlDataHandlerCacheMock = new Mock<IXmlDataHandlerCache>();
            Mock<IXmlDataHandlerCacheFactory> xmlDataHandlerCacheFactoryMock = new Mock<IXmlDataHandlerCacheFactory>();
            xmlDataHandlerCacheFactoryMock.Setup(c => c.Create(It.IsAny<IXmlDataReader>())).Returns(xmlDataHandlerCacheMock.Object);

            XmlDataHandler xmlDataHandler = new XmlDataHandler("path", xmlDataReaderFactoryMock.Object,
                xmlDataWriterFactoryMock.Object, xmlDataHandlerCacheFactoryMock.Object);

            IEnumerable<List<string>> readValues = await xmlDataHandler.GetValues<XmlDataHandlerTest, List<string>>("property");
        }
    }
}