// -----------------------------------------------------------------------
// <copyright file="IdleBatchTest.cs" company="Microsoft">
// TODO: Update copyright text.
// </copyright>
// -----------------------------------------------------------------------

using System.Collections.Concurrent;
using System.ComponentModel;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;
using NUnit.Framework;
using Pithos.Core.Agents;

namespace Pithos.Core.Test
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    [TestFixture]
    public class IdleBatchTest
    {


        [Test]
        public void TestEnqueue()
        {
            var queue=new ConcurrentQueue<FileSystemEventArgs>();
            var batch = new IdleBatch<FileSystemEventArgs>(1000,queue.AddFromEnumerable );
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created,"path1","file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.ForceTrigger();
            
            Assert.That(queue.Count,Is.EqualTo(4));
        }

        [Test]
        public void TestTimeout()
        {
            var queue=new ConcurrentQueue<FileSystemEventArgs>();
            var batch = new IdleBatch<FileSystemEventArgs>(100,queue.AddFromEnumerable );
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created,"path1","file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);
            
            Assert.That(queue.Count,Is.EqualTo(4));
            queue.Clear();
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);
            
            Assert.That(queue.Count,Is.EqualTo(2));
        }

        [Test]
        public void TestCreationSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);

            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created,"path1","file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events[@"path1\file1"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Created }));
        }

        [Test]
        public void TestCreateDeleteSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);

            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created,"path1","file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Deleted, "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"), Is.False); 
        }

        [Test]
        public void TestChangeSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);
            
            Assert.That(events[@"path1\file1"].Select(arg=>arg.ChangeType),Is.EquivalentTo(new[]{WatcherChangeTypes.Changed}));
        }
        
        [Test]
        public void TestEnsureEmptyAfterTrigger()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);
            Assert.That(events[@"path1\file1"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Changed }));
            events = new Dictionary<string, FileSystemEventArgs[]>();
            Thread.Sleep(500);
            Assert.That(events, Is.Empty);
        }
        
        [Test]
        public void TestChangeDeleteSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Deleted, "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events[@"path1\file1"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Deleted }));
        }

        [Test]
        public void TestCreateChangeDeleteSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Deleted, "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"), Is.False);            
        }

        [Test]
        public void TestCreateDeleteCreateSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Deleted, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events[@"path1\file1"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Created }));
        }

        public void TestCreateCreateSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file2"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file2"));
            Thread.Sleep(500);

            Assert.That(events[@"path1\file1"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Created }));
            Assert.That(events[@"path1\file2"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Created }));
        }

        [Test]
        public void TestCreateRenameSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new MovedEventArgs("path1", "file2", "path1", "file1"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"), Is.False);
            var changes = events[@"path1\file2"];
            Assert.That(changes.Length,Is.EqualTo(1));
            var change = changes[0];
            Assert.That(change.ChangeType, Is.EqualTo(WatcherChangeTypes.Created));
            Assert.That(change.FullPath,Is.EqualTo("path1\\file2"));                        
        }

        [Test]
        public void TestRenameChangeSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new MovedEventArgs("path1", "file2","path1","file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file2"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"),Is.False);
            Assert.That(events["path1\\file2"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Renamed, WatcherChangeTypes.Changed }));
        }

        [Test]
        public void TestCreateRenameChangeSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new MovedEventArgs("path1", "file2", "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file2"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"), Is.False);
            var changes = events["path1\\file2"];
            Assert.That(changes.Length, Is.EqualTo(1));
            var change = changes[0];
            Assert.That(change.ChangeType, Is.EqualTo(WatcherChangeTypes.Created));
            Assert.That(change.FullPath, Is.EqualTo(@"path1\file2"));
            
        }

        [Test]
        public void TestCreateRenameChangeDeleteSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100, dict => events = dict);
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new MovedEventArgs("path1", "file2", "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file2"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Deleted, "path1", "file2"));
            Thread.Sleep(500);

            Assert.That(events.ContainsKey("path1\\file1"), Is.False);
            Assert.That(events.ContainsKey("path1\\file2"), Is.False);
            
        }

        [Test]
        public void TestCreateRenameOtherSequence()
        {
            Dictionary<string, FileSystemEventArgs[]> events = null;
            var batch = new FileEventIdleBatch(100,dict=>events=dict);
            
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Created, "path1", "file1"));
            batch.Post(new FileSystemEventArgs(WatcherChangeTypes.Changed, "path1", "file1"));
            batch.Post(new MovedEventArgs("path1", "file3", "path1", "file2"));
            Thread.Sleep(500);
            

            Assert.That(events.ContainsKey("path1\\file1"),Is.True);
            Assert.That(events.ContainsKey("path1\\file2"), Is.False);
            Assert.That(events[@"path1\file3"].Select(arg => arg.ChangeType), Is.EquivalentTo(new[] { WatcherChangeTypes.Renamed }));
        }
    }
}