// Copyright (C) Stichting Deltares 2019. 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.Collections;
using System.Collections.Generic;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.DamEngine.Data.Standard.Validation;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Forms;
using Deltares.Standard.Forms.DExpress;
using Deltares.Standard.Reflection;

namespace Deltares.Dam.Forms
{
    public class DamContext: GeotechnicsContext
    {
        private bool wti = true;

        private Dictionary<Type, Dictionary<string, List<string>>> filters = new Dictionary<Type, Dictionary<string, List<string>>>();

        private const string LocationScenarioInsideStability = "InsideStabilityScenarioCategory";
        private const string LocationScenarioPiping = "PipingScenarioCategory";
        private const string LocationScenarioPlLineSchematization = "PlLineSchematizationScenarioCategory";
        
        public bool Wti
        {
            get { return wti; }
            set { wti = value; }
        }

        public DamContext()
        {
            SetUpFilterDictionary();
        }

        private void SetUpFilterDictionary()
        {
            var locationScenarioFilter = new Dictionary<string, List<string>>();

            filters[typeof(Scenario)] = locationScenarioFilter;

            locationScenarioFilter.Add(LocationScenarioInsideStability, new List<string>
            {
                StaticReflection.GetMemberName<Scenario>(x => x.LocationScenarioID),
                StaticReflection.GetMemberName<Scenario>(x => x.RiverLevel),
                StaticReflection.GetMemberName<Scenario>(x => x.DikeTableHeight),
                StaticReflection.GetMemberName<Scenario>(x => x.RequiredSafetyFactorStabilityInnerSlope),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl3),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl4),
                StaticReflection.GetMemberName<Scenario>(x => x.PolderLevel)
            });

            locationScenarioFilter.Add(LocationScenarioPiping, new List<string>
            {
                StaticReflection.GetMemberName<Scenario>(x => x.LocationScenarioID),
                StaticReflection.GetMemberName<Scenario>(x => x.RiverLevel),
                StaticReflection.GetMemberName<Scenario>(x => x.DikeTableHeight),
                StaticReflection.GetMemberName<Scenario>(x => x.RequiredSafetyFactorPiping),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl3),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl4),
                StaticReflection.GetMemberName<Scenario>(x => x.PolderLevel)
            });

            locationScenarioFilter.Add(LocationScenarioPlLineSchematization, new List<string>
            {
                StaticReflection.GetMemberName<Scenario>(x => x.LocationScenarioID),
                StaticReflection.GetMemberName<Scenario>(x => x.RiverLevel),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetBelowDikeTopAtRiver),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetBelowDikeTopAtPolder),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetBelowShoulderBaseInside),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetBelowDikeToeAtPolder),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetBelowDikeCrestMiddle),
                StaticReflection.GetMemberName<Scenario>(x => x.PlLineOffsetFactorBelowShoulderCrest),
                StaticReflection.GetMemberName<Scenario>(x => x.UsePlLineOffsetBelowDikeCrestMiddle),
                StaticReflection.GetMemberName<Scenario>(x => x.UsePlLineOffsetFactorBelowShoulderCrest),
                StaticReflection.GetMemberName<Scenario>(x => x.PolderLevel)
            });
        }

        /// <summary>
        /// Returns the possible named filters for a given type.
        /// </summary>
        /// <param name="type">A type for which named filters will be returned.</param>
        /// <returns>A <see cref="IEnumerable{T}"/> of the named filters or null if no named filters exists.</returns>
        public IEnumerable<string> GetColumnNamedFilters(Type type)
        {
            if (filters.ContainsKey(type))
            {
                return filters[type].Keys.ToArray();
            }
            return null;
        }

        /// <summary>
        /// Returns a list of visible properties for a type and a named filter returned by <see cref="GetColumnNamedFilters"/>.
        /// </summary>
        /// <param name="type">A type for which named filters are defined.</param>
        /// <param name="value">One of the named filters for this type.</param>
        /// <returns>A list of visible properties.</returns>
        public IList<string> GetFilteredColumns(Type type, string value)
        {
            if (filters.ContainsKey(type) && filters[type].ContainsKey(value))
            {
                return filters[type][value];
            }
            return null;
        }

        /// <summary>
        /// Method indicating a visibility override value for a given instance object.
        /// </summary>
        /// <param name="source">Object being evaluated.</param>
        /// <param name="member">Name of the member which is part of <paramref name="source" />.</param>
        /// <returns>
        /// True if visible; False if hidden; Null if no override.
        /// </returns>
        public override bool? IsVisible(object source, string member)
        {
            var locationScenariosControl = source as LocationScenariosControl;
            if (null != locationScenariosControl)
            {
                if (member == StaticReflection.GetMemberName<LocationScenariosControl>(x => x.SelectedContextFilter))
                {
                    return locationScenariosControl.HasItems;
                }
            }

            if (source is SoilList)
            {
                switch (member)
                {
                    case "Soils" : return Wti;
                }
            }

            if (source is Location && member == StaticReflection.GetMemberName<Location>(x => x.SurfaceLine2))
            {
                return false;
            }

            if (source is Location && member == StaticReflection.GetMemberName<Location>(x => x.LocalXZSurfaceLine2))
            {
                return true;
            }
            // Make sure unwanted operations are hidden for the surface line grid for now.
            var grid = source as GridViewControl;
            if (grid != null)
            {
                if ((member == "AddRowCommand" || member == "DeleteRowCommand" || member == "PasteCommand" || member == "EditCommand") && (grid.Name == "SurfaceLinePointsGridControl"))
                {
                    return false;
                }
            }

            if (source is VisualValidationResult)
            {
                // Make sure that for DAM, all repairers are not used.
                var vr = (VisualValidationResult) source;
                vr.Repairer = null;
            }
            return base.IsVisible(source, member);
        }

        /// <summary>
        /// Method indicating if the enabled override value for a given instance object.
        /// </summary>
        /// <param name="source">Object being evaluated.</param>
        /// <param name="member">Name of the member which is part of <paramref name="source" />.</param>
        /// <returns>
        /// True if enabled; False if disabled; Null if no override.
        /// </returns>
        public override bool? IsEnabled(object source, string member)
        {
            // Make sure CharacteristicPoints can not be edited for now.
            if (source is CharacteristicPoint)
            {
                if (member == StaticReflection.GetMemberName<CharacteristicPoint>(x => x.X) ||
                    member == StaticReflection.GetMemberName<CharacteristicPoint>(x => x.Y) ||
                    member == StaticReflection.GetMemberName<CharacteristicPoint>(x => x.Z))
                {
                    return false;
                }
                return true;                
            }

            if (source is Soil && member != StaticReflection.GetMemberName<Soil>(x => x.StrengthIncreaseExponent))
            {
                return false;
            }
            var specification = source as DamProjectCalculationSpecification;
            if (specification != null)
            {
                if (member == "SelectedStabilityKernelType")
                {
                    return Wti;
                }
            }
            return base.IsEnabled(source, member);
        }

        /// <summary>
        /// Returns a collection of allowed values for a property as part of the IDomain interface.
        /// This is used for populating drop down values in a drop down list.
        /// Note that this isn’t necessary when the property is defined as an enumeration.
        /// All enumeration values are used by default.
        /// </summary>
        /// <param name="property">The name of the property for which to return the possible values.</param>
        /// <returns>
        /// A <see cref="T:System.Collections.ICollection" /> containing the possible values for the given property.
        /// </returns>
        public override ICollection GetDomain(string property)
        {
            if (property == "CharacteristicPointType")
            {
                return new List<CharacteristicPointType>
                {
                    CharacteristicPointType.SurfaceLevelOutside,
                    CharacteristicPointType.DikeToeAtRiver,
                    CharacteristicPointType.ShoulderTopOutside,
                    CharacteristicPointType.ShoulderBaseOutside,
                    CharacteristicPointType.DikeTopAtRiver,
                    CharacteristicPointType.TrafficLoadOutside,
                    CharacteristicPointType.TrafficLoadInside,
                    CharacteristicPointType.DikeTopAtPolder,
                    CharacteristicPointType.ShoulderBaseInside,
                    CharacteristicPointType.ShoulderTopInside,
                    CharacteristicPointType.DikeToeAtPolder,
                    CharacteristicPointType.DitchDikeSide,
                    CharacteristicPointType.BottomDitchDikeSide,
                    CharacteristicPointType.BottomDitchPolderSide,
                    CharacteristicPointType.DitchPolderSide,
                    CharacteristicPointType.SurfaceLevelInside,
                    CharacteristicPointType.None,
                };
            }
            return base.GetDomain(property);
        }
    }
}