// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.IO;
using System.Linq;
using System.Threading;
using NUnit.Framework;

namespace Deltares.Maps.Tests.Services
{
    [TestFixture]
    public class ShapeFileCreatorTest
    {
        private readonly string pathOutputFolder = Path.Combine(Directory.GetCurrentDirectory(), @"ShapeFileTestFiles\");
        private FeatureRepository repository;
        private string fileName;
        private string shpFile;
        private string dbfFile;
        private string shxFile;
        private string shpFilePath;
        private string shxFilePath;
        private string dbfFilePath;

        [Test]
        public void CreateFile_ValidPathAndNoFeatures_Throws()
        {
            Assert.That(() => ShapeFileCreator.Create(@"", fileName, repository), Throws.ArgumentException);
        }

        [Test]
        public void CreateFile_InvalidName_Throws()
        {
            Assert.That(() => ShapeFileCreator.Create(@"", "", repository), Throws.ArgumentNullException);
        }

        [Test]
        public void CreateFile_RepositoryContainsDifferentGeometryTypes_Throws()
        {
            repository.Add(Feature.Create("LINESTRING EMPTY"));
            repository.Add(Feature.Create("POINT(0 0)"));
            Assert.That(() => ShapeFileCreator.Create(@"", fileName, repository), Throws.InstanceOf<NetTopologySuite.IO.Esri.ShapefileException>().With.Message.EqualTo("Invalid geometry type provided (LineString). Expected: Point."));
        }

        [Test]
        public void CreateFile_ValidPathAndRepositoryContainsOneLineString_ShapeFileIsCreated()
        {
            repository.Add(Feature.Create("LINESTRING (10 10, 10 20)"));
            ShapeFileCreator.Create(pathOutputFolder, fileName, repository);

            AssertThatMandatoryFilesExist();

            var shapeFile = new ShapeFileLocation(shpFilePath);
            IFeatureRepository retrievedRepository = FeatureRepository.CreateFromShapeFile(shapeFile);
            Assert.That(retrievedRepository, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(retrievedRepository.Count, Is.EqualTo(1));
                Assert.That(repository.Features.ElementAt(0).Geometry.GeometryType, Is.EqualTo("LineString"));
            });
        }

        [Test]
        public void CreateFile_ValidPathAndRepositoryContainsOneLineStringAndOneMultiLineString_ShapeFileIsCreated()
        {
            repository.Add(Feature.Create("LINESTRING (10 10, 10 20)"));
            repository.Add(Feature.Create("MULTILINESTRING ((10 10, 20 20, 10 40),(40 40, 30 30, 40 20, 30 10))"));
            ShapeFileCreator.Create(pathOutputFolder, fileName, repository);

            AssertThatMandatoryFilesExist();

            var shapeFile = new ShapeFileLocation(shpFilePath);
            IFeatureRepository retrievedRepository = FeatureRepository.CreateFromShapeFile(shapeFile);
            Assert.That(retrievedRepository, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(retrievedRepository.Count, Is.EqualTo(2));
                Assert.That(repository.Features.Any(f => f.Geometry.GeometryType == "LineString"), Is.True);
                Assert.That(repository.Features.Any(f => f.Geometry.GeometryType == "MultiLineString"), Is.True);
            });
        }

        [Test]
        public void CreateFile_ValidPathAndRepositoryContainsOnePoint_ShapeFileIsCreated()
        {
            repository.Add(Feature.Create("POINT(0 0)"));
            ShapeFileCreator.Create(pathOutputFolder, fileName, repository);

            AssertThatMandatoryFilesExist();

            var shapeFile = new ShapeFileLocation(shpFilePath);
            IFeatureRepository retrievedRepository = FeatureRepository.CreateFromShapeFile(shapeFile);
            Assert.That(retrievedRepository, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(retrievedRepository.Count, Is.EqualTo(1));
                Assert.That(repository.Features.ElementAt(0).Geometry.GeometryType, Is.EqualTo("Point"));
            });
        }

            [Test]
        public void CreateFile_ValidPathAndRepositoryContainsMultiPoint_ShapeFileIsCreated()
        {
            repository.Add(Feature.Create("MULTIPOINT (10 40, 40 30, 20 20, 30 10)"));
            ShapeFileCreator.Create(pathOutputFolder, fileName, repository);

            AssertThatMandatoryFilesExist();

            var shapeFile = new ShapeFileLocation(shpFilePath);
            IFeatureRepository retrievedRepository = FeatureRepository.CreateFromShapeFile(shapeFile);
            Assert.That(retrievedRepository, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(retrievedRepository.Count, Is.EqualTo(1));
                Assert.That(repository.Features.ElementAt(0).Geometry.GeometryType, Is.EqualTo("MultiPoint"));
            });
        }

        private void AssertThatMandatoryFilesExist()
        {
            Assert.Multiple(() =>
            {
                Assert.That(File.Exists(shpFilePath), Is.True, $"{shpFile} does not exist");
                Assert.That(File.Exists(dbfFilePath), Is.True, $"{dbfFile} does not exist");
                Assert.That(File.Exists(shxFilePath), Is.True, $"{shxFile} does not exist");
            });
        }

        #region Setup

        [SetUp]
        public void FixtureSetup()
        {
            if (Directory.Exists(pathOutputFolder))
            {
                Directory.Delete(pathOutputFolder, true);
            }

            Directory.CreateDirectory(pathOutputFolder);
        }

        [TearDown]
        public void FixtureTearDown() {}

        [SetUp]
        public void TestSetup()
        {
            fileName = "TestFile_" + Guid.NewGuid().ToString().Replace("-", "_");
            shpFile = fileName + ".shp";
            dbfFile = fileName + ".dbf";
            shxFile = fileName + ".shx";

            shpFilePath = Path.Combine(pathOutputFolder, shpFile);
            shxFilePath = Path.Combine(pathOutputFolder, shxFile);
            dbfFilePath = Path.Combine(pathOutputFolder, dbfFile);

            if (File.Exists(shpFilePath))
            {
                File.Delete(shpFilePath);
            }

            if (File.Exists(shxFilePath))
            {
                File.Delete(shxFilePath);
            }

            if (File.Exists(dbfFilePath))
            {
                File.Delete(dbfFilePath);
            }

            repository = new FeatureRepository();
        }

        [TearDown]
        public void TestTearDown()
        {
            if (File.Exists(shpFilePath))
            {
                File.Delete(shpFilePath);
            }

            if (File.Exists(shxFilePath))
            {
                File.Delete(shxFilePath);
            }

            if (File.Exists(dbfFilePath))
            {
                // disposing the dbf file could take longer
                for (var i = 0; i < 3; i++)
                {
                    try
                    {
                        File.Delete(dbfFilePath);
                    }
                    catch (IOException)
                    {
                        Thread.Sleep(200);
                    }
                }
            }
        }

        #endregion
    }
}