using GitConverter.Lib.Converters;
using GitConverter.TestsApp.TestSupport;

namespace GitConverter.TestsApp.Converters
{
    /// <summary>
    /// Integration tests for Shapefile conversion flows.
    /// </summary>
    /// <remarks>
    /// Purpose
    /// - Exercise end-to-end shapefile conversion using the real ConversionService and ShapefileConverter
    ///   against small sample archives placed under TestData\Shapefile.
    ///
    /// Behavior & expectations
    /// - Tests are defensive: they skip when no TestData is present so CI remains non-fatal.
    /// - For each sample archive the tests create an isolated temp output folder and temp extraction folder.
    /// - On success the converter should produce one or more files in the output folder.
    /// - On failure the converter should return a ConversionResult.Failure with a non-empty diagnostic message.
    ///
    /// Implementation notes
    /// - Uses IntegrationTestConstants.TestDataShapefileFolder to locate sample artifacts at runtime.
    /// - Uses ConversionService.Run to exercise the high-level orchestrator (this calls into registered converters).
    /// - Also exercises ShapefileConverter.Convert directly for a single extracted archive (if present).
    /// - Cleanup: temporary folders are removed in Dispose / finally blocks where possible.
    /// </remarks>
    [Collection("Integration")]
    public class ShapefileConverterIntegrationTests : IDisposable
    {
        private readonly string _root;

        public ShapefileConverterIntegrationTests()
        {
            // Use a per-test temp root to avoid collisions across tests/runs
            _root = Path.Combine(Path.GetTempPath(), "GitConverter.ShapefileTests", Guid.NewGuid().ToString("N"));
            Directory.CreateDirectory(_root);
        }

        public void Dispose()
        {
            try { if (Directory.Exists(_root)) Directory.Delete(_root, true); } catch { }
        }

        private static string TestDataShapefileFolder => IntegrationTestConstants.TestDataShapefileFolder;

        [Fact(DisplayName = "ConversionService.Run processes shapefile archives (if present)")]
        public void Run_ShapefileArchives_ProduceOutputs_WhenPresent()
        {
            if (!Directory.Exists(TestDataShapefileFolder))
            {
                // No samples provided; skip test.
                return;
            }

            var samples = Directory.EnumerateFiles(TestDataShapefileFolder, "*", SearchOption.TopDirectoryOnly)
                                   .Where(f => f.EndsWith(".7z", StringComparison.OrdinalIgnoreCase) || f.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
                                   .ToList();

            if (!samples.Any())
                return;

            foreach (var sample in samples)
            {
                var outDir = Path.Combine(_root, Path.GetFileNameWithoutExtension(sample) + "_out");
                var tempDir = Path.Combine(_root, Path.GetFileNameWithoutExtension(sample) + "_tmp");
                Directory.CreateDirectory(outDir);
                Directory.CreateDirectory(tempDir);

                try
                {
                    var result = ConversionService.Run(sample, outDir, tempDir, factory: null);

                    Assert.NotNull(result);
                    if (result.IsSuccess)
                    {
                        Assert.True(Directory.Exists(outDir), $"Expected output folder '{outDir}' for '{sample}'.");
                        var files = Directory.EnumerateFiles(outDir, "*", SearchOption.AllDirectories).ToList();
                        Assert.True(files.Count > 0, $"Expected one or more output files in '{outDir}' for '{sample}'.");
                    }
                    else
                    {
                        // On failure ensure a diagnostic message is present
                        Assert.False(string.IsNullOrWhiteSpace(result.Message), $"Conversion failed for '{sample}' but produced no message.");
                    }
                }
                finally
                {
                    try { if (Directory.Exists(outDir)) Directory.Delete(outDir, true); } catch { }
                    try { if (Directory.Exists(tempDir)) Directory.Delete(tempDir, true); } catch { }
                }
            }
        }

        [Fact(DisplayName = "ShapefileConverter.Convert direct call against first archive (if present)")]
        public void Convert_Archive_ToAllTargetOptions_WhenArchivePresent()
        {
            if (!Directory.Exists(TestDataShapefileFolder))
                return;

            var sample = Directory.EnumerateFiles(TestDataShapefileFolder, "*", SearchOption.TopDirectoryOnly)
                                  .FirstOrDefault(f => f.EndsWith(".7z", StringComparison.OrdinalIgnoreCase) || f.EndsWith(".zip", StringComparison.OrdinalIgnoreCase));
            if (sample == null) return;

            var converter = new ShapefileConverter();

            foreach (var target in IntegrationTestConstants.TargetOptions)
            {
                var outDir = Path.Combine(_root, $"{Path.GetFileNameWithoutExtension(sample)}_{target}_out");
                var tempDir = Path.Combine(_root, $"{Path.GetFileNameWithoutExtension(sample)}_{target}_tmp");
                Directory.CreateDirectory(outDir);
                Directory.CreateDirectory(tempDir);

                try
                {
                    var result = converter.Convert(sample, target, outDir, tempDir);
                    Assert.NotNull(result);
                    if (result.IsSuccess)
                    {
                        var files = Directory.EnumerateFiles(outDir, "*", SearchOption.AllDirectories).ToList();
                        Assert.True(files.Count > 0, $"No output files produced for target '{target}' when converting '{sample}'.");
                    }
                    else
                    {
                        Assert.False(string.IsNullOrWhiteSpace(result.Message), $"Conversion to '{target}' failed with empty message ({sample}).");
                    }
                }
                finally
                {
                    try { if (Directory.Exists(outDir)) Directory.Delete(outDir, true); } catch { }
                    try { if (Directory.Exists(tempDir)) Directory.Delete(tempDir, true); } catch { }
                }
            }
        }
    }
}