// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of Riskeer.
//
// Riskeer 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.Collections.Generic;
using System.IO;
using System.Linq;
using Components.Persistence.Stability;
using Core.Common.Base.Data;
using Core.Common.Base.IO;
using Core.Common.Util;
using log4net;
using Riskeer.Common.Data.Calculation;
using Riskeer.Common.Forms.Helpers;
using Riskeer.MacroStabilityInwards.Data;
using Riskeer.MacroStabilityInwards.IO.Properties;
using CoreCommonUtilResources = Core.Common.Util.Properties.Resources;
using CoreCommonGuiResources = Core.Common.Gui.Properties.Resources;

namespace Riskeer.MacroStabilityInwards.IO.Exporters
{
    /// <summary>
    /// Exports macro stability inwards calculations from a calculation group and stores them as separate stix files.
    /// </summary>
    public class MacroStabilityInwardsCalculationGroupExporter : IFileExporter
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(MacroStabilityInwardsCalculationGroupExporter));

        private readonly CalculationGroup calculationGroup;
        private readonly IPersistenceFactory persistenceFactory;
        private readonly string folderPath;
        private readonly string fileExtension;
        private readonly Func<MacroStabilityInwardsCalculation, RoundedDouble> getNormativeAssessmentLevelFunc;

        /// <summary>
        /// Creates a new instance of <see cref="MacroStabilityInwardsCalculationGroupExporter"/>.
        /// </summary>
        /// <param name="calculationGroup">The calculation group to export.</param>
        /// <param name="persistenceFactory">The persistence factory to use.</param>
        /// <param name="folderPath">The folder path to export to.</param>
        /// <param name="fileExtension">The extension of the files.</param>
        /// <param name="getNormativeAssessmentLevelFunc"><see cref="Func{T1,TResult}"/>
        /// for obtaining the normative assessment level.</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationGroup"/>, <paramref name="persistenceFactory"/>
        /// or <paramref name="getNormativeAssessmentLevelFunc"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException">Thrown when <paramref name="folderPath"/> is invalid.</exception>
        /// <remarks>A valid path:<list type="bullet">
        /// <item>is not empty or <c>null</c>,</item>
        /// <item>does not consist out of only whitespace characters,</item>
        /// <item>does not contain an invalid character,</item>
        /// <item>is not too long.</item>
        /// </list></remarks>
        public MacroStabilityInwardsCalculationGroupExporter(CalculationGroup calculationGroup, IPersistenceFactory persistenceFactory, string folderPath,
                                                             string fileExtension, Func<MacroStabilityInwardsCalculation, RoundedDouble> getNormativeAssessmentLevelFunc)
        {
            if (calculationGroup == null)
            {
                throw new ArgumentNullException(nameof(calculationGroup));
            }

            if (persistenceFactory == null)
            {
                throw new ArgumentNullException(nameof(persistenceFactory));
            }

            if (getNormativeAssessmentLevelFunc == null)
            {
                throw new ArgumentNullException(nameof(getNormativeAssessmentLevelFunc));
            }

            IOUtils.ValidateFolderPath(folderPath);

            this.calculationGroup = calculationGroup;
            this.persistenceFactory = persistenceFactory;
            this.folderPath = folderPath;
            this.fileExtension = fileExtension;
            this.getNormativeAssessmentLevelFunc = getNormativeAssessmentLevelFunc;
        }

        public bool Export()
        {
            return ExportCalculationItemsRecursively(calculationGroup, folderPath);
        }

        private bool ExportCalculationItemsRecursively(CalculationGroup groupToExport, string currentFolderPath)
        {
            CreateDirectory(currentFolderPath);

            var continueExport = true;
            var exportedGroups = new List<CalculationGroup>();
            var exportedCalculations = new List<MacroStabilityInwardsCalculation>();

            foreach (ICalculationBase calculationItem in groupToExport.Children)
            {
                switch (calculationItem)
                {
                    case CalculationGroup nestedGroup when HasChildrenWithOutput(nestedGroup):
                        continueExport = ExportCalculationGroup(nestedGroup, currentFolderPath, exportedGroups);
                        break;
                    case MacroStabilityInwardsCalculation calculation when !calculation.HasOutput:
                        log.WarnFormat(Resources.MacroStabilityInwardsCalculationGroupExporter_Export_Calculation_0_has_no_output_and_is_skipped, calculation.Name);
                        break;
                    case MacroStabilityInwardsCalculation calculation:
                        continueExport = ExportCalculation(calculation, currentFolderPath, exportedCalculations);
                        break;
                }

                if (!continueExport)
                {
                    return false;
                }
            }

            return true;
        }

        private static bool HasChildrenWithOutput(CalculationGroup nestedGroup)
        {
            MacroStabilityInwardsCalculation[] calculations = nestedGroup.Children.OfType<MacroStabilityInwardsCalculation>()
                                                                         .ToArray();
            return calculations.Any() && calculations.All(calculation => calculation.HasOutput);
        }

        private static void CreateDirectory(string currentFolderPath)
        {
            if (!Directory.Exists(currentFolderPath))
            {
                Directory.CreateDirectory(currentFolderPath);
            }
        }

        private bool ExportCalculationGroup(CalculationGroup nestedGroup, string currentFolderPath, ICollection<CalculationGroup> exportedGroups)
        {
            string uniqueGroupName = NamingHelper.GetUniqueName(exportedGroups, nestedGroup.Name, group => group.Name);

            bool exportSucceeded = ExportCalculationItemsRecursively(nestedGroup, Path.Combine(currentFolderPath, uniqueGroupName));
            if (!exportSucceeded)
            {
                return false;
            }

            exportedGroups.Add(nestedGroup);
            return true;
        }

        private bool ExportCalculation(MacroStabilityInwardsCalculation calculation, string currentFolderPath, ICollection<MacroStabilityInwardsCalculation> exportedCalculations)
        {
            log.InfoFormat(CoreCommonGuiResources.GuiExportHandler_ExportItemUsingDialog_Start_exporting_DataType_0_, calculation.Name);

            string filePath = GetCalculationFilePath(calculation, currentFolderPath, exportedCalculations);
            var exporter = new MacroStabilityInwardsCalculationExporter(calculation, persistenceFactory, filePath, () => getNormativeAssessmentLevelFunc(calculation));

            bool exportSucceeded = exporter.Export();
            if (!exportSucceeded)
            {
                log.ErrorFormat("{0} {1}", string.Format(CoreCommonUtilResources.Error_General_output_error_0, filePath), Resources.MacroStabilityInwardsCalculationExporter_Export_no_stability_project_exported);
                return false;
            }

            log.InfoFormat(Resources.MacroStabilityInwardsCalculationGroupExporter_Export_Data_from_0_exported_to_file_1, calculation.Name, filePath);
            exportedCalculations.Add(calculation);
            return true;
        }

        private string GetCalculationFilePath(ICalculationBase calculation, string currentFolderPath, IEnumerable<MacroStabilityInwardsCalculation> exportedCalculations)
        {
            string uniqueName = NamingHelper.GetUniqueName(exportedCalculations, calculation.Name, c => c.Name);
            string fileNameWithExtension = $"{uniqueName}.{fileExtension}";
            return Path.Combine(currentFolderPath, fileNameWithExtension);
        }
    }
}