// Copyright (C) Stichting Deltares 2025. 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.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.Attributes;
using Deltares.Standard.Forms;
using Deltares.Standard.Forms.DExpress;
using Deltares.Standard.Forms.Maps;
using Deltares.Standard.Reflection;
using DevExpress.Utils.Menu;
using DevExpress.XtraTreeList;
using DevExpress.XtraTreeList.Menu;

namespace Deltares.Dam.Forms
{
    public class DamContext : GeotechnicsContext
    {
        public DamContext()
        {
            SetUpLocationsFilters();
            SetUpSoilsFilters();
        }

        /// <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)
            {
                return true;
            }

            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;
            }

            var soil = source as DamSoil;
            if (soil != null)
            {
                bool? visibleAccordingSoilUserFilter = VisibleAccordingSoilUserFilter(member);
                if (visibleAccordingSoilUserFilter != null)
                {
                    return visibleAccordingSoilUserFilter;
                }
            }

            // 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 DikeTreeView dikeTreeView)
            {
                TreeList treeList = dikeTreeView.TreeList;
                treeList.PopupMenuShowing += DikeTreeListPopupMenuShowing;
            }

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

            if (source is CsvExportData && member.Equals("ResultSlices"))
            {
                return false;
            }

            bool? isVisible = base.IsVisible(source, member);
            if (isVisible != null && isVisible.Value)
            {
                return true;
            }

            return isVisible;
        }

        /// <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)
        {
            // Legend in DotSpatial 1.8 uses ContextMenu which is not supported in .NET6
            if (source is MapEditor)
            {
                if (member == "ShowLegend")
                {
                    return false;
                }
            }

            // 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 SoilList)
            {
                return true;
            }

            if (source is DamSoil soil)
            {
                if (member == StaticReflection.GetMemberName<DamSoil>(s => s.Name) || 
                    member == StaticReflection.GetMemberName<DamSoil>(s => s.StressTable) || 
                    member == StaticReflection.GetMemberName<DamSoil>(s => s.SuTable))
                {
                    return false;
                }

                if (member == StaticReflection.GetMemberName<DamSoil>(s => s.POP) ||
                    member == StaticReflection.GetMemberName<DamSoil>(s => s.RatioCuPc) ||
                    member == StaticReflection.GetMemberName<DamSoil>(s => s.StrengthIncreaseExponent))
                {
                    return soil.ShearStrengthModel == ShearStrengthModel.CuCalculated;
                }
                
                if (member == StaticReflection.GetMemberName<DamSoil>(s => s.Cohesion) ||
                    member == StaticReflection.GetMemberName<DamSoil>(s => s.FrictionAngle))
                {
                    return soil.ShearStrengthModel == ShearStrengthModel.CPhi;
                }

                return true;
            }

            if (source is GridViewControl grid)
            {
                // Make sure you can not add or delete soil material 
                if (grid.Name == "MaterialsGridViewControl" && member is "DeleteRowCommand" or "AddRowCommand")
                {
                    return false;
                }
            }

            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
                };
            }

            if (property == "SoilUserFilter")
            {
                return GetSoilUserFilters();
            }

            return base.GetDomain(property);
        }

        public override ICollection GetDomain(object source, string member)
        {
            if (source is DamSoil && member == StaticReflection.GetMemberName<DamSoil>(s => s.ShearStrengthModel))
            {
                return new List<ShearStrengthModel>
                {
                    ShearStrengthModel.CPhi,
                    ShearStrengthModel.CuCalculated,
                    ShearStrengthModel.StressTable,
                    ShearStrengthModel.SuTable
                };
            }

            return null;
        }

        public override string GetFormat(Type type, object source, string member)
        {
            if ((type == typeof(DamSoil) || source is DamSoil) && (member == StaticReflection.GetMemberName<DamSoil>(x => x.PermeabKx)))
            {
                return "E3";
            }

            return base.GetFormat(type, source, member);
        }

        private bool? VisibleAccordingSoilUserFilter(string member)
        {
            if (alwaysVisibleProperties.Contains(member))
            {
                return true;
            }

            HashSet<string> filteredProperties = GetFilteredProperties(SoilUserFilter);

            if (filteredProperties == null)
            {
                return null;
            }

            return filteredProperties.Contains(member);
        }

        private static void DikeTreeListPopupMenuShowing(object sender, PopupMenuShowingEventArgs e)
        {
            if (e.Menu is TreeListColumnMenu columnMenu)
            {
                DXMenuItem showAutoFilterRowItem = columnMenu.Items
                                                             .FirstOrDefault(item => item.Caption == "Show Auto Filter Row");
                if (showAutoFilterRowItem != null)
                {
                    showAutoFilterRowItem.Visible = false;
                }

                DXMenuItem filterEditorItem = columnMenu.Items
                                                        .FirstOrDefault(item => item.Caption == "Filter Editor...");
                if (filterEditorItem != null)
                {
                    filterEditorItem.Visible = false;
                }
            }
        }

        #region SoilFilters

        private readonly HashSet<string> alwaysVisibleProperties = new HashSet<string>
        {
            StaticReflection.GetMemberName<DamSoil>(s => s.Name),
            StaticReflection.GetMemberName<DamSoil>(s => s.Color),
            StaticReflection.GetMemberName<DamSoil>(s => s.SoilType)
        };

        private readonly HashSet<string> macrostabilitySoilProperties = new HashSet<string>
        {
            StaticReflection.GetMemberName<DamSoil>(s => s.AbovePhreaticLevel),
            StaticReflection.GetMemberName<DamSoil>(s => s.BelowPhreaticLevel),
            StaticReflection.GetMemberName<DamSoil>(s => s.ShearStrengthModel),
            StaticReflection.GetMemberName<DamSoil>(s => s.Cohesion),
            StaticReflection.GetMemberName<DamSoil>(s => s.FrictionAngle),
            StaticReflection.GetMemberName<DamSoil>(s => s.POP),
            StaticReflection.GetMemberName<DamSoil>(s => s.RatioCuPc),
            StaticReflection.GetMemberName<DamSoil>(s => s.StrengthIncreaseExponent),
            StaticReflection.GetMemberName<DamSoil>(s => s.StressTable),
            StaticReflection.GetMemberName<DamSoil>(s => s.TrafficLoadDegreeOfConsolidation)
        };

        private readonly HashSet<string> pipingSoilProperties = new HashSet<string>
        {
            StaticReflection.GetMemberName<DamSoil>(s => s.AbovePhreaticLevel),
            StaticReflection.GetMemberName<DamSoil>(s => s.BelowPhreaticLevel),
            StaticReflection.GetMemberName<DamSoil>(s => s.DiameterD70),
            StaticReflection.GetMemberName<DamSoil>(s => s.PermeabKx)
        };

        private HashSet<string> combinedSoilProperties;

        private void SetUpSoilsFilters()
        {
            SoilUserFilter = UserColumnFilters.MacrostabilityWti;
            combinedSoilProperties = new HashSet<string>();
            combinedSoilProperties.UnionWith(macrostabilitySoilProperties);
            combinedSoilProperties.UnionWith(pipingSoilProperties);
        }

        protected override HashSet<string> GetFilteredProperties(object userColumnFilters)
        {
            return combinedSoilProperties;
        }

        #endregion SoilFilters

        #region LocationFilters

        private readonly 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";

        private void SetUpLocationsFilters()
        {
            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),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl2)
            });

            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),
                StaticReflection.GetMemberName<Scenario>(x => x.HeadPl2)
            });

            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;
        }

        #endregion LocationFilters
    }
}