using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Deltares.DSoilModel.Data;
using Deltares.DSoilModel.Forms;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Mechanisms;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.Forms.DExpress;
using Deltares.Standard.Reflection;
using NUnit.Framework;

namespace Deltares.DSoilModel.Tests
{
    public class DSoilModelContextTest
    {
        #region Properties for user column filters member tests

        private readonly HashSet<string> excludedProperties = new HashSet<string>
        {
            "StressTableStochast",
            "UseDefaultShearStrengthModel"
        };

        private readonly HashSet<string> alwaysVisibleProperties = new HashSet<string>
        {
            "Name",
            "Description",
            "Color",
            "SoilType"
        };

        #endregion

        [TestCase(UserColumnFilters.MacrostabilityBasicModule, Mechanism.Stability)]
        [TestCase(UserColumnFilters.PipingRingtoets, Mechanism.Piping)]
        public void SoilFiltering_UserColumnFilterForMechanism_HasMembersWithSameMechanism(UserColumnFilters filter, Mechanism mechanism)
        {
            var membersInFilterDefinition = GetFilterDefinition(filter);
            var membersWithMechanismAttribute = GetPropertiesWithMechanismAttribute(mechanism);
            var passAllMembers = true;

            foreach (var member in membersInFilterDefinition)
            {
                var memberIsInMechanismScope = (alwaysVisibleProperties.Contains(member) || membersWithMechanismAttribute.Contains(member));
                var errorMessage = string.Format("Soil property {0} in filter {1} has no mechanism attribute {2}.", member, filter, mechanism);

                if (!memberIsInMechanismScope)
                {
                    Console.WriteLine(errorMessage);
                    passAllMembers = false;
                }
            }
            Assert.IsTrue(passAllMembers, "The filter " + filter + " is not defined correctly.");
        }

        [Test]
        public void SoilFiltering_AllUserColumnFilters_MembersUniquelyDefined()
        {
            var userColumnFilters = Enum.GetValues(typeof(UserColumnFilters));

            foreach (var filterObject in userColumnFilters)
            {
                var filter = (UserColumnFilters)filterObject;
                var membersInFilterDefinition = GetFilterDefinition(filter);
                var membersInFilterDefinitionList = new List<string>();

                if (membersInFilterDefinition != null)
                {
                    membersInFilterDefinitionList = membersInFilterDefinition.ToList();
                }
                membersInFilterDefinitionList.AddRange(alwaysVisibleProperties);
                var passAllMembers = true;

                if (membersInFilterDefinitionList.Distinct().Count() != membersInFilterDefinitionList.Count())
                {
                    var duplicateMembers = membersInFilterDefinitionList.GroupBy(m => m).Where(group => group.Count() > 1).Select(group => group.Key);

                    foreach (var duplicateMember in duplicateMembers)
                    {
                        var errorMessage = string.Format("Soil property {0} in filter {1} was defined duplicately.", duplicateMember, filter);
                        Console.WriteLine(errorMessage);
                        passAllMembers = false;
                    }
                    Assert.IsTrue(passAllMembers, "The filter " + filter + " is not defined correctly.");
                }
            }
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsVisible_AdhereToFilterAll()
        {
            var dSoilModelContext = SetupDSoilModelContext(null); // Filter "All"
            var testSoil = new Soil();

            var type = testSoil.GetType();
            var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
            foreach (var property in properties)
            {
                var propertyName = property.Name;
                var isVisible = dSoilModelContext.IsVisible(testSoil, propertyName);
                if (excludedProperties.Contains(property.Name))
                {
                    Assert.IsTrue(isVisible == false, "Soil property " + propertyName + " should not be visible.");
                }
                else
                {
                    Assert.IsTrue(isVisible != false, "Soil property " + propertyName + " should be visible.");
                }
            }
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsVisible_AdhereToFilterMacrostabilityBasicModule()
        {
            var visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.Cohesion),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngle),
                StaticReflection.GetMemberName<Soil>(s => s.RatioCuPc),
                StaticReflection.GetMemberName<Soil>(s => s.StrengthIncreaseExponent),
                StaticReflection.GetMemberName<Soil>(s => s.POP),
                StaticReflection.GetMemberName<Soil>(s => s.ShearStrengthModel),
                StaticReflection.GetMemberName<Soil>(s => s.UsePop)
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(UserColumnFilters.MacrostabilityBasicModule, visibleProperties);
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsEnabled_AdhereToFilterMacrostabilityBasicModule()
        {
            var context = SetupDSoilModelContext(UserColumnFilters.MacrostabilityBasicModule);
            var soil = new Soil
            {
                ShearStrengthModel = ShearStrengthModel.CPhi,
                UseDefaultShearStrengthModel = false, // or it will mess up this test !

            };
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.Cohesion)));
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.FrictionAngle)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.UsePop)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.POP)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.RatioCuPc)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.StrengthIncreaseExponent)));
            
            soil.ShearStrengthModel = ShearStrengthModel.CuCalculated;
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.Cohesion)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.FrictionAngle)));
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.UsePop)));
            soil.UsePop = true;
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.POP)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.RatioCuPc)));
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.StrengthIncreaseExponent)));
            soil.UsePop = false;
            Assert.AreEqual(false, context.IsEnabled(soil, soil.GetMemberName(s => s.POP)));
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.RatioCuPc)));
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.StrengthIncreaseExponent)));
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsVisible_AdhereToFilterPipingRingToets()
        {
            var visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD70Stochast),   
                StaticReflection.GetMemberName<Soil>(s => s.PermeabKxStochast),
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevelStochast),
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(UserColumnFilters.PipingRingtoets, visibleProperties);
        }

        [Test]
        public void DSoilModelContext_ParameterViewForPreconsolidationStress_Visibility()
        {
            var dSoilModelContext = SetupDSoilModelContext(null);
            var pcs = new PreConsolidationStress();

            dSoilModelContext.ParameterView = ParameterViewSettings.AllParameters;
            var isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressValue));
            Assert.IsTrue(isVisible != null && isVisible.Value);
            isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressStochast));
            Assert.IsTrue(isVisible != null && isVisible.Value);

            dSoilModelContext.ParameterView = ParameterViewSettings.AsIsParameters;
            isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressValue));
            Assert.IsTrue(isVisible != null && isVisible.Value);
            isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressStochast));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            dSoilModelContext.ParameterView = ParameterViewSettings.ProbabilisticParameters;
            isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressValue));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
            isVisible = dSoilModelContext.IsVisible(pcs, pcs.GetMemberName(x => x.StressStochast));
            Assert.IsTrue(isVisible != null && isVisible.Value);
        }

        [Test]
        public void DSoilModelContext_Mainform_InvisibleItems()
        {
            About.IgnoreAssemblyErrors = true;
            using (var mainForm = new MainForm())
            {
                var context = new DSoilModelContext();
                Assert.AreEqual(false, context.IsVisible(mainForm, "SelectUnits"));
                Assert.AreEqual(false, context.IsVisible(mainForm, "ExecuteDeleteCommand"));
            }
        }

        private static void AdhereToFilter(UserColumnFilters filter, ICollection<string> visibleProperties)
        {
            var dSoilModelContext = SetupDSoilModelContext(filter);
            var testSoil = new Soil();
            var visiblePropertiesOrdered = visibleProperties.OrderBy(s => s);

            foreach (var propertyName in visiblePropertiesOrdered)
            {
                var isVisible = dSoilModelContext.IsVisible(testSoil, propertyName);
                var propertyVisible = isVisible != null && (bool)isVisible;

                Assert.IsTrue(propertyVisible, "Soil property " + propertyName + " should be visible.");
            }

            var type = testSoil.GetType();
            var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
            var propertyNames = properties.Select(property => property.Name).ToList();

            foreach (var propertyName in propertyNames)
            {
                if (!visibleProperties.Contains(propertyName))
                {
                    var isVisible = dSoilModelContext.IsVisible(testSoil, propertyName);
                    var propertyVisible = isVisible != null && (bool)isVisible;

                    Assert.IsFalse(propertyVisible, "Soil property " + propertyName + " should not be visible.");
                }
            }
        }

        private static DSoilModelContext SetupDSoilModelContext(UserColumnFilters? userColumnFilter)
        {
            var dSoilModelContext = new DSoilModelContext
            {
                ParameterView = ParameterViewSettings.AllParameters,
                SoilUserFilter = userColumnFilter
            };
            return dSoilModelContext;
        }

        private static HashSet<string> GetFilterDefinition(UserColumnFilters filter)
        {
            var method = typeof(DSoilModelContext).GetMethod("GetFilteredProperties", BindingFlags.NonPublic | BindingFlags.Instance);
            var dSoilmodelContext = new DSoilModelContext();
            var arguments = new object[] { filter };

            var filteredPropertiesHashSet = method.Invoke(dSoilmodelContext, arguments) as HashSet<string>;

            return filteredPropertiesHashSet;
        }

        private static HashSet<string> GetPropertiesWithMechanismAttribute(Mechanism mechanism)
        {
            var membersWithMechanismDefined = new HashSet<string>();

            var testSoil = new Soil();
            var properties = testSoil.GetType().GetProperties();

            foreach (var propertyInfo in properties.Where(propertyInfo => propertyInfo.HasMechanism(mechanism)))
            {
                membersWithMechanismDefined.Add(propertyInfo.Name);
            }

            return membersWithMechanismDefined;
        }

        [Test]
        public void TestSoilProfile1DVisibility()
        {
            var dSoilModelContext = SetupDSoilModelContext(null);
            var sp1 = new SoilProfile1D();
            
            var isVisible = dSoilModelContext.IsVisible(sp1, sp1.GetMemberName(x => x.X));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
            isVisible = dSoilModelContext.IsVisible(sp1, sp1.GetMemberName(x => x.Y));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
        }
    }
}