using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using CommandLine;
using Deltares.Dam.Data;
using Deltares.Dam.Tests;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;

namespace Deltares.Dam.KernelComparisonRunner
{
    /// <summary>
    /// 
    /// </summary>
    internal class Program
    {
        /// <summary>
        /// Main method
        /// </summary>
        /// <param name="args">The arguments.</param>
        static void Main(string[] args)
        {
            var commandLineArguments = new CommandOptions();
            ICommandLineParser parser = new CommandLineParser();
            bool success = parser.ParseArguments(args, commandLineArguments);
            if (success)
            {
                var program = new Program();

                program.StartCalculations(
                    commandLineArguments.DamXFileName,
                    commandLineArguments.KernelSpecificationFileName,
                    commandLineArguments.LocationsFileName,
                    commandLineArguments.OutputPath);
            }
            else
            {
                Console.WriteLine();
                Console.WriteLine(commandLineArguments.GetUsage());
            }
        }

        /// <summary>
        /// Starts the calculations.
        /// </summary>
        /// <param name="damxFilename">The damx filename.</param>
        /// <param name="kernelSpecificationFilename">The kernel specification filename.</param>
        /// <param name="locationsFilename">The locations filename.</param>
        /// <param name="outputPath">The output path.</param>
        private void StartCalculations(string damxFilename, string kernelSpecificationFilename, string locationsFilename, string outputPath)
        {
            List<StabilityKernelType> kernelsToCalculate = ReadKernels(kernelSpecificationFilename);
            List<string> locationsList = ReadLocations(locationsFilename);
            TextWriter textWriter = CreateTextWriter(outputPath);
            ComparisonTestRunner runner = new ComparisonTestRunner();
            ComparisonTestRunner.Tolerances = new DamIntegrationTestTolerance();
            ComparisonTestRunner.PropertiesToCheck = new[] { "SafetyFactor", "Zone1EntryPointX", "Zone1EntryPointZ", "Zone1ExitPointX", "Zone1ExitPointZ" };
            ComparisonTestRunner.DamWtiTestReportsDir = outputPath;
            try
            {
                DataEventPublisher.InvokeWithoutPublishingEvents(() =>
                {
                    List<string> testMessagesNotOk = runner.RunStabilityComparisonTest(damxFilename, locationsList,kernelsToCalculate, textWriter);
                });
            }
            finally
            {
                textWriter.Flush();
                textWriter.Dispose();
            }
        }

        /// <summary>
        /// Reads the kernels.
        /// </summary>
        /// <param name="kernelSpecificationFilename">The kernel specification filename.</param>
        /// <returns></returns>
        private List<StabilityKernelType> ReadKernels(string kernelSpecificationFilename)
        {
            if (String.IsNullOrEmpty(kernelSpecificationFilename))
            {
                return new List<StabilityKernelType>()
                {
                    StabilityKernelType.DamClassic,
                    StabilityKernelType.DamClassicWti
                };
            }
            else
            {
                var lines = File.ReadAllLines(kernelSpecificationFilename);
                var stabilityKernels = new List<StabilityKernelType>();
                foreach (string line in lines)
                {
                    StabilityKernelType type = (StabilityKernelType)Enum.Parse(typeof(StabilityKernelType), line);
                    stabilityKernels.Add(type);
                }
                return stabilityKernels;
            }
        }

        /// <summary>
        /// Reads the locations.
        /// </summary>
        /// <param name="locationsFilename">The locations filename.</param>
        /// <returns></returns>
        private List<string> ReadLocations(string locationsFilename)
        {
            if (String.IsNullOrEmpty(locationsFilename))
            {
                return null;
            }
            else
            {
                return File.ReadAllLines(locationsFilename).ToList();
            }
        }


        /// <summary>
        /// Creates the text writer.
        /// </summary>
        /// <param name="outputPath">The output path.</param>
        /// <returns></returns>
        private TextWriter CreateTextWriter(string outputPath)
        {
            string wtiDamComparisonTxTFullPath = Path.Combine(outputPath, "comparison.txt");
            if (!Directory.Exists(outputPath))
            {
                Directory.CreateDirectory(outputPath);
            }
            if (File.Exists(wtiDamComparisonTxTFullPath))
            {
                File.Delete(wtiDamComparisonTxTFullPath);
            }
            var textWriter = new StreamWriter(wtiDamComparisonTxTFullPath, true);
            return textWriter;
        }
    }
}