using System.IO;
using System.Linq;
using System.Xml;
using NUnit.Framework;
using OpenTap.Package;
using OpenTap.Plugins.BasicSteps;

namespace OpenTap.UnitTests
{
    [Display("Some test step")]
    public class MyTestStep : TestStep
    {
        [FilePath(FilePathAttribute.BehaviorChoice.Open)]
        public string StringPath { get; set; }

        [FilePath(FilePathAttribute.BehaviorChoice.Open)]
        public MacroString MacroPath { get; set; }

        public string SomeString { get; set; }

        public override void Run()
        {
        }
    }

    [TestFixture]
    public class TestPlanDependencyTest
    {
        private string[] _files => new[] {ReferencedFile, ReferencedFile2, PictureReference};
        private const string os = "Windows,Linux";
        private const string version = "3.4.5";
        private const string TestPackageName = "FakePackageReferencingFile";
        private const string ReferencedFile = "TestPlanFromPackage.TapPlan";
        public const string PictureReference = "SomePicture.png";
        private const string NotReferencedFile = "OtherFile.txt";
        private const string TestStepName = "Just a name for the step";
        private string ReferencedFile2 => $"Packages/{TestPackageName}/{ReferencedFile}";

        private string TestPackageXml => $@"<?xml version=""1.0"" encoding=""UTF-8""?>
<Package Name=""{TestPackageName}"" xmlns=""http://opentap.io/schemas/package"" Version=""{version}"" OS=""{os}"" >
  <Files>
      <File Path=""{ReferencedFile}""/>
      <File Path=""{ReferencedFile2}""/>
      <File Path=""{PictureReference}""/>
      <File Path=""{Path.GetFileName(typeof(MyTestStep).Assembly.Location)}""/>
  </Files>
</Package>
";

        private string PackageXmlPath =>
            Path.Combine(ExecutorClient.ExeDir, "Packages", TestPackageName, "package.xml");

        public string PreviousDirectory { get; set; }

        /// <summary>
        /// Engine unittests run in a temp directory it seems, and this test relies on the current installation
        /// </summary>
        [SetUp]
        public void SetDirectory()
        {
            PreviousDirectory = Directory.GetCurrentDirectory();
            Directory.SetCurrentDirectory(ExecutorClient.ExeDir);
        }
        
        [SetUp]
        public void Uninstall()
        {
            FileSystemHelper.EnsureDirectoryOf(PackageXmlPath);
            if (File.Exists(PackageXmlPath))
                File.Delete(PackageXmlPath);

            foreach (var file in _files)
            {
                if (File.Exists(file))
                    File.Delete(file);
            }
            
            Installation.Current.Invalidate();
        }

        [TearDown]
        public void TearDown()
        {
            Directory.SetCurrentDirectory(PreviousDirectory);
        }

        void VerifyDependency(string attr, string name, int count, XmlDocument document)
        {
            var nodes = document.SelectNodes(
                $"/TestPlan/Package.Dependencies/Package[@Name='{TestPackageName}']/{attr}[@Name='{name}']");
            Assert.AreEqual(count, nodes.Count);
        }

        [Test]
        public void TestPictureDependency()
        {
            InstallPackage();
            var plan = new TestPlan();
            var pic = new MyPictureUsingTestStep();
            pic.Picture.Source = PictureReference;
            plan.ChildTestSteps.Add(pic);

            var xml = plan.SerializeToString();

            var document = new XmlDocument();
            document.LoadXml(xml);

            VerifyDependency("File", PictureReference, 1, document);
        }

        [Test]
        public void TestFindInvalidPath()
        {
            var file = new string(Path.GetInvalidFileNameChars());
            var a = Installation.Current.FindPackageContainingFile(file);
            Assert.IsNull(a);

            var file2 = "abc/def : ghi.txt";
            var b = Installation.Current.FindPackageContainingFile(file2);
            Assert.IsNull(b);
        }


        [Test]
        public void TestPackageFileDependencies()
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new MyTestStep()
            {
                StringPath = ReferencedFile, MacroPath = new MacroString() {Text = ReferencedFile2},
                SomeString = NotReferencedFile,
                Name = TestStepName
            });

            var planXml = plan.SerializeToString();
            var document = new XmlDocument();
            document.LoadXml(planXml);

            void VerifyDependency(string attr, string name, int count)
            {
                this.VerifyDependency(attr, name, count, document);
            }


            // Verify warnings when files used by test steps are missing
            {
                VerifyDependency("File", ReferencedFile, 0);
                VerifyDependency("File", ReferencedFile2, 0);
                VerifyDependency("Type", typeof(MyTestStep).FullName, 0);
                VerifyDependency("File", NotReferencedFile, 0);

                var ser = new TapSerializer();
                ser.DeserializeFromString(planXml);
                var errors = ser.Errors.ToArray();

                Assert.AreEqual(0, errors.Length, "Expected no errors.");
            }

            // Verify no serializer errors when files are present
            {
                InstallPackage();
                // OnSearch invalidates the cache of currently installed packages;
                // otherwise the serializer will not detect that we have added a package 
                // And add the files the package is expected to contain
                Installation.Current.Invalidate();

                planXml = plan.SerializeToString();
                document.LoadXml(planXml);

                VerifyDependency("File", ReferencedFile, 1);
                VerifyDependency("File", ReferencedFile2, 1);
                // Uncomment when <Type> attributes are added to Package.Dependencies child elements
                // VerifyDependency("Type", typeof(MyTestStep).FullName, 1);
                VerifyDependency("File", NotReferencedFile, 0);

                var ser = new TapSerializer();
                ser.DeserializeFromString(planXml);
                var errors = ser.Errors.ToArray();

                Assert.AreEqual(0, errors.Length, "Expected 0 errors.");
            }

            Installation.Current.Invalidate();

            // Verify serializer errors when required package and files are missing
            {
                // Remove the package again
                Uninstall();

                var ser = new TapSerializer();
                ser.DeserializeFromString(planXml);
                var errors = ser.Errors.ToArray();

                // Expect a warning for the two [FilePath] properties on the test step
                // Expect an error for the missing package and two errors for the missing files
                Assert.AreEqual(3, errors.Length, "Expected 3 errors.");
                Assert.IsTrue(errors.Any(e =>
                    e.Contains(
                        $"Package '{TestPackageName}' is required to load, but it is not installed.")));
                Assert.IsTrue(errors.Any(e =>
                    e.Contains(
                        $"File '{ReferencedFile}' from package '{TestPackageName}' is required by the test plan, but it could not be found.")));
                Assert.IsTrue(errors.Any(e =>
                    e.Contains(
                        $"File '{ReferencedFile2}' from package '{TestPackageName}' is required by the test plan, but it could not be found.")));
            }
        }

        // Create fake install of the package
        private void InstallPackage()
        {
            File.WriteAllText(PackageXmlPath, TestPackageXml);
            foreach (var file in _files)
            {
                var fullPath = Path.Combine(ExecutorClient.ExeDir, file);
                File.WriteAllText(fullPath, "test");
            }
        }

        [Test]
        [TestCase(".")]
        [TestCase("../")]
        [TestCase("../../")]
        public void TestFindPackageOf(string workingDirectory)
        {
            var start = Directory.GetCurrentDirectory();
            try
            {
                Directory.SetCurrentDirectory(workingDirectory);
                // Test FindPackageContainingType(TypeData)
                {
                    var td = TypeData.FromType(typeof(MyTestStep));

                    var p1 = Installation.Current.FindPackageContainingType(td);
                    Assert.IsNull(p1);
                    InstallPackage();
                    var p2 = Installation.Current.FindPackageContainingType(td);
                    // The package should be null because the cache is not invalidated
                    Assert.IsNull(p2);
                    Installation.Current.Invalidate();
                    var p3 = Installation.Current.FindPackageContainingType(td);
                    Assert.IsNotNull(p3);

                    StringAssert.AreEqualIgnoringCase(p3.Name, TestPackageName);
                    StringAssert.AreEqualIgnoringCase(p3.Version.ToString(), version);
                }

                Uninstall();

                // Test FindPackageContainingFile("File/Path")
                {
                    var filename = ReferencedFile2;
                    var p1 = Installation.Current.FindPackageContainingFile(filename);
                    Assert.IsNull(p1);
                    InstallPackage();
                    var p2 = Installation.Current.FindPackageContainingFile(filename);
                    // The package should be null because the cache is not invalidated
                    Assert.IsNull(p2);
                    Installation.Current.Invalidate();
                    var p3 = Installation.Current.FindPackageContainingFile(filename);
                    Assert.IsNotNull(p3);

                    StringAssert.AreEqualIgnoringCase(p3.Name, TestPackageName);
                    StringAssert.AreEqualIgnoringCase(p3.Version.ToString(), version);
                }
            }
            finally
            {
                Directory.SetCurrentDirectory(start);
            }
        }
        
        public class TestResultListener : ResultListener
        {
            public  TestPlanRun LatestRun { get; private set; }
            public bool WasRun { get; set; } = false;

            public void Clear()
            {
                WasRun = false;
                LatestRun = null;
            }

            public TestResultListener()
            {
            }

            public override void OnTestPlanRunStart(TestPlanRun planRun)
            {
                LatestRun = planRun;
                WasRun = true;
            }
            
        }
        [Test]
        public void EnsureParameterAttached()
        {
            var parameterName = "Test Plan Package";
            using (Session.Create())
            {
                var listener = new TestResultListener();
                ResultSettings.Current.Add(listener);

                var plan = new TestPlan();

                // Plan which is not from a package
                { 
                    Assert.IsFalse(listener.WasRun);
                    plan.ChildTestSteps.Add(new DelayStep());
                    plan.Execute();

                    var parameterValue = listener.LatestRun.Parameters[parameterName];
                    Assert.IsNull(parameterValue);
                    Assert.IsTrue(listener.WasRun);
                }
                
                listener.Clear();
                Assert.IsFalse(listener.WasRun);

                // Plan which is from a package
                {
                    Assert.IsFalse(listener.WasRun);
                    InstallPackage();
                    Installation.Current.Invalidate();

                    var packageDef = Installation.Current.FindPackageContainingFile(ReferencedFile);
                    
                    plan.Save(ReferencedFile);
                    plan.Execute();

                    Assert.IsTrue(listener.WasRun);

                    var parameterValue = listener.LatestRun.Parameters[parameterName];
                    Assert.AreEqual($"{TestPackageName}|{version}|{packageDef.ComputeHash()}", parameterValue);
                    Assert.IsTrue(listener.WasRun);
                }
            }
        }
    }
}