// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the DAM Engine.
//
// The DAM Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero 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;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.General.SchematizationFactor;
using Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.RWScenarios;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Language;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.General
{
    public class DamProjectData
    {
        public readonly double MissValStabilitySafetyFactor = -1.0;
        private WaterBoard waterBoard;
        private DamProjectCalculationSpecification damProjectCalculationSpecification;
        private WaterBoardJob waterBoardJob = null;
        private DamProjectType damProjectType = DamProjectType.Calamity;
        private ProgramType programType = ProgramType.MStab;
        private List<LocationJob> jobs = new List<LocationJob>();
        private SchematizationFactorData schematizationFactorData = new SchematizationFactorData();
        private List<RWScenarioProfileResult> calculations = null; // will be created and initialized in property
        private List<CsvExportData> designCalculations = null;
        private List<RWSchematizationFactorResult> schematizationFactors = null; 
        private SensorData sensorData;

        /// <summary>
        /// Constructor
        /// </summary>
        public DamProjectData()
        {
            this.waterBoard = new WaterBoard();
            this.waterBoardJob = null;
            this.damProjectCalculationSpecification = new DamProjectCalculationSpecification();            
        }

        public static string ProjectWorkingPath 
        {
            get;
            set;
        }

        public static string MStabExePath
        {
            get;
            set;
        }

        public static string SlopeWExePath
        {
            get;
            set;
        }

        /// <summary>
        /// Toplevel object to hold waterboard data
        /// </summary>
        public virtual WaterBoard WaterBoard
        {
            get { return this.waterBoard; }
            set
            {
                this.waterBoard = value;
                if (this.waterBoardJob != null && this.waterBoardJob.Subject != value)
                {
                    this.waterBoardJob = null;
                }
            }
        }
        /// <summary>
        /// calculation specification for the project
        /// </summary>
        /// <remarks>Composite relationship</remarks>
        [Validate]
        public DamProjectCalculationSpecification DamProjectCalculationSpecification
        {
            get { return damProjectCalculationSpecification; }
            set { damProjectCalculationSpecification = value; }

        }
       
        public virtual DamJob WaterBoardJob
        {
            get
            {
                if (waterBoardJob == null)
                {
                    waterBoardJob = new WaterBoardJob(this.waterBoard);
                    waterBoardJob.Subject = this.waterBoard;

                    foreach (Dike dike in waterBoard.Dikes)
                    {
                        CompositeJob dikeJob = new DikeJob(dike);
                        waterBoardJob.Jobs.Add(dikeJob);

                        foreach (Location location in dike.Locations)
                        {
                            LocationJob locationJob = new LocationJob(location);
                            dikeJob.Jobs.Add(locationJob);
                        }
                    }
                }

                return waterBoardJob;
            }
            set { waterBoardJob = value as WaterBoardJob; }
        }

        public virtual DamProjectType DamProjectType
        {
            get { return damProjectType; }
            set
            {
                bool modified = damProjectType != value;

                damProjectType = value;
                Location.DamProjectType = value;
                DamFailureMechanismeCalculationSpecification.DamProjectType = value;

                if (modified)
                {
                    LocationJob.DamProjectType = damProjectType;                    
                }                
            }
        }
        
        [XmlIgnore]
        public List<RWScenarioProfileResult> Calculations
        {
            get
            {
                if (calculations == null)
                {
                    calculations = new List<RWScenarioProfileResult>();
                    this.UpdateCalculations();
                }

                return calculations;
            }
        }

        /// <summary>
        /// Clear all results
        /// </summary>
        public void ClearResults()
        {
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                locationJob.LocationResult = new LocationResult();
                foreach (Scenario scenario in locationJob.Location.Scenarios)
                {
                    scenario.CalculationResults.Clear();
                }
            }
        }

        public void UpdateCalculations()
        {
            if (calculations != null)
            {
                calculations.Clear();

                foreach (LocationJob locationJob in this.LocationJobs)
                {
                    if (locationJob.HasRWScenarioResults)
                    {
                        foreach (RWScenarioResult locationResult in locationJob.RWScenarioResults)
                        {
                            calculations.AddRange(locationResult.RWScenarioProfileResults);
                        }
                    }
                }                
            }
        }

        private List<Scenario> CreateScenarioListForDeletion()
        {
            List<Scenario> scenarios = new List<Scenario>(); ;

            List<Location> locations = this.LocationJobs.Select(x => x.Location).ToList();
            foreach (Location location in locations)
            {
                if (location.Scenarios != null)
                {
                    scenarios.AddRange(location.Scenarios);
                }
            }

            return scenarios;
        }

        private List<Scenario> CreateScenarioListForCalculation()
        {
            List<Scenario> scenarios = new List<Scenario>(); ;

            List<Location> locations = this.SelectedLocationJobs.Select(x => x.Location).ToList();
            foreach (Location location in locations)
            {
                if (location.Scenarios != null)
                {
                    scenarios.AddRange(location.Scenarios);
                }
            }

            return scenarios;
        }

        /// <summary>
        /// Updates the design calculations.
        /// </summary>
        public void UpdateDesignCalculations()
        {
            if (designCalculations == null)
            {
                designCalculations = new List<CsvExportData>();
            }
            else
            {
                designCalculations.Clear();    
            }
			var scenarios = CreateScenarioListForCalculation();
            foreach (Scenario scenario in scenarios)
            {
                if (scenario.CalculationResults != null && scenario.CalculationResults.Count > 0)
                {
                    designCalculations.AddRange(scenario.CalculationResults);
                }
            }            
        }

        [XmlIgnore]
        public List<CsvExportData> DesignCalculations
        {
            get
            {
                if (designCalculations == null)
                {
                    this.UpdateDesignCalculations();
                }

                return designCalculations;
            }
        }

        [XmlIgnore]
        public List<RWSchematizationFactorResult> SchematizationFactors
        {
            get
            {
                if (schematizationFactors == null)
                {
                    schematizationFactors = new List<RWSchematizationFactorResult>();
                    this.UpdateSchematizationFactors();
                }

                return schematizationFactors;
            }
        }

        public void UpdateSchematizationFactors()
        {
            if (schematizationFactors != null)
            {
                schematizationFactors.Clear();

                foreach (LocationJob locationJob in this.LocationJobs)
                {
                    if (locationJob.HasSchematizationFactorResults)
                    {
                        foreach (
                            var rwSchematizationFactorResult in
                                locationJob.LocationResult.SchematizationFactorsResult.SchematizationFactorResults)
                        {
                            schematizationFactors.Add(rwSchematizationFactorResult);
                        }
                    }
                }                
            }
        }

        public SchematizationFactorData SchematizationFactorData
        {
            get { return schematizationFactorData; }
            set
            {
                schematizationFactorData = value;                
            }
        }

        public CalculationResult Validate()
        {
            try
            {
                //Todo validation has to extended, handling the actual messages instead of just CalculationResult too.
                foreach (Dike dike in this.WaterBoard.Dikes)
                {
                    dike.Validate();
                }
                return CalculationResult.Succeeded;
            }
            catch
            {
                return CalculationResult.InvalidInputData;
            }
        }

        public LocationJob GetLocationJob(Location location)
        {
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if (locationJob.Location == location)
                {
                    return locationJob;
                }
            }

            return null;
        }

        [XmlIgnore]
        public List<LocationJob> LocationJobs
        {
            get
            {
                if (jobs.Count == 0)
                {
                    CompositeJob waterboardJob = this.WaterBoardJob as CompositeJob;
                    foreach (CompositeJob dijkJob in waterboardJob.Jobs)
                    {
                        foreach (LocationJob locationJob in dijkJob.Jobs)
                        {
                            jobs.Add(locationJob);
                        }
                    }
                }

                return jobs;
            }
        }

        public LocationJob GetFirstLocationJobWithDesignResults()
        {
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if (locationJob.HasScenarioResults)
                {
                    return locationJob;
                }
            }
            return null;
        }

        public LocationJob GetFirstLocationJobWithAssesmentResults()
        {
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if (locationJob.HasRWScenarioResults)
                {
                    return locationJob;
                }
            }
            return null;
        }

        public LocationJob GetFirstLocationJobWithCalamityResults()
        {
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if (locationJob.HasLocationResults)
                {
                    return locationJob;
                }
            }
            return null;
        }

        [XmlIgnore]
        [Validate]
        public List<LocationJob> SelectedLocationJobs
        {
            get
            {
                List<LocationJob> selectedLocationJobs = new List<LocationJob>();
                foreach (LocationJob locationJob in this.LocationJobs)
                {
                    if (locationJob.Run.HasValue && locationJob.Run.Value)
                    {
                        selectedLocationJobs.Add(locationJob);
                    }
                }

                return selectedLocationJobs;
            }
        }

        [Validate]
        public ValidationResult[] ValidateEnoughLocationJobs()
        {
            if (this.SelectedLocationJobs.Count == 0)
            {
                return new ValidationResult[]
                           {
                               new ValidationResult(ValidationResultType.Error,
                                                    LocalizationManager.GetTranslatedText(this, "NoLocationsSelected"),
                                                    this)
                           };
            }
            else
            {
                return new ValidationResult[0];
            }
        }

        [XmlIgnore]
        public List<Location> Locations
        {
            get { return this.WaterBoard.Locations; }
        }

        public ProgramType ProgramType
        {
            // For now, only MStab (= default value) allowed so ReadOnly. Add setter when needed.
            get { return programType; }
        }

        /// <summary>
        /// Gets or sets the sensor data.
        /// </summary>
        /// <value>
        /// The sensor data.
        /// </value>      
        public SensorData SensorData
        {
            get { return sensorData; }
            set { sensorData = value; }
        }

        public EvaluationJob GetEvaluationJob()
        {
            EvaluationJob evaluationJob = new EvaluationJob();

            evaluationJob.DikeName = this.WaterBoard.Dikes[0].Name;
            //evaluationJob.MapForSoilGeometries2D = this.WaterBoard.Dikes[0].MapForSoilGeometries2D;
            //evaluationJob.SoildatabaseName = this.WaterBoard.Dikes[0].SoilDatabaseName;

            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if (locationJob.Run != null && locationJob.Run.Value)
                {
                    foreach (Dike dike in this.WaterBoard.Dikes)
                    {
                        if (dike.Locations.Contains(locationJob.Location))
                        {
                            dike.UpdateLocation(locationJob.Location);
                            break;
                        }
                    }

                    evaluationJob.Locations.Add(locationJob.Location);
                }
            }

            return evaluationJob;
        }

        /// <summary>
        /// Ensures the proper zone safety factors are available for all locations.
        /// </summary>
        public void EnsureProperZoneSafetyFactors()
        {
            foreach (var location in Locations)
            {
                location.EnsureProperZoneSafetyFactors();
            }   
        }

        public void DeleteResults()
        {
            if (waterBoardJob != null && waterBoardJob.Jobs != null)
            {
                waterBoardJob.Jobs.Clear();
            }
            waterBoardJob = null;
            if (jobs != null)
            {
                jobs.Clear();
            }
            if (calculations != null)
            {
                calculations.Clear();                
            }
            if (schematizationFactors != null)
            {
                schematizationFactors.Clear();                
            }

            // Delete calculationresults in scenarios
            var scenarios = CreateScenarioListForDeletion();
            foreach (Scenario scenario in scenarios)
            {
                scenario.ClearResults();
                scenario.ClearErrors();
            }

            if (designCalculations != null)
            {
                designCalculations.Clear();
            }            
        }

        private EvaluationJob GetCalculatedEvaluationJob()
        {
            EvaluationJob evaluationJob = new EvaluationJob();

            evaluationJob.DikeName = this.WaterBoard.Dikes[0].Name;
            
            foreach (LocationJob locationJob in this.LocationJobs)
            {
                if ((locationJob.Result != JobResult.NoRun || (locationJob.HasRWScenarioResults))  && locationJob.Run != null && locationJob.Run.Value)
                {
                    foreach (Dike dike in this.WaterBoard.Dikes)
                    {
                        if (dike.Locations.Contains(locationJob.Location))
                        {
                            dike.UpdateLocation(locationJob.Location);
                            break;
                        }
                    }

                    evaluationJob.Locations.Add(locationJob.Location);
                }
            }

            return evaluationJob;
        }

        public bool HasResults()
        {
            bool hasResults = waterBoard.Dikes.Count > 0 && waterBoardJob != null && waterBoardJob.Jobs.Count > 0;
            if (hasResults)
            {
                EvaluationJob evaluationJob = GetCalculatedEvaluationJob();
                hasResults =  evaluationJob.Locations != null && evaluationJob.Locations.Count > 0;
            }
            return hasResults;
        }

        /// <summary>
        /// Check if design with geometry adaption is allowed
        /// </summary>
        /// <returns></returns>
        private bool IsDesignWithGeometryAdaptionAllowed()
        {
            bool isAdoption = this.DamProjectType == DamProjectType.Design && DamProjectCalculationSpecification.SelectedAnalysisType != AnalysisType.NoAdaption;
            bool isStabilityOutside = this.DamProjectCalculationSpecification.DamCalculationSpecifications.Any(specification => specification.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside);
            return (!isAdoption || !isStabilityOutside);
        }

        /// <summary>
        /// Validates the geometry adaption setting.
        /// </summary>
        /// <returns></returns>
        [Validate]
        public ValidationResult[] ValidateGeometryAdaptionSetting()
        {
            if (!IsDesignWithGeometryAdaptionAllowed())
            {
                return new[]{ new ValidationResult(ValidationResultType.Error, LocalizationManager.GetTranslatedText(this, "DesignAndAdaptionNotAllowedForStabilityOutside"),
                    this)};
            }
            else
            {
                return new ValidationResult[0];
            }

        }
        
        public override string ToString()
        {
            return this.WaterBoard != null ? this.WaterBoard.Name : "";
        }
        

        public void FillOverallSensorData()
        {
            if (sensorData != null)
            {
                sensorData.Sensors.Clear();
                sensorData.SensorGroups.Clear();
                sensorData.SensorLocations.Clear();
            }
            else
            {
                sensorData = new SensorData();    
            }
            foreach (var location in Locations)
            {
                var sd = location.SensorData;
                
                foreach (var sensor in sd.Sensors )
                {
                    if (sensorData.GetSensorById(sensor.ID) == null)
                    {
                        sensorData.Sensors.Add(sensor);
                    }
                }
                if (sensorData.GetGroupById(sd.Group.ID) == null && sd.Group.ID >= 0)
                {
                    sd.Group.PickSensors = sensorData.Sensors;
                    sensorData.SensorGroups.Add(sd.Group);
                }
                if (sensorData.GetSensorLocationByLocationName(sd.LocationName) == null)
                {
                    sensorData.SensorLocations.Add(sd);
                }
            }            
        }
    }
}