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

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

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

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

        #endregion

        [TestCase(UserColumnFilters.MacrostabilityWti, Mechanism.Stability)]
        [TestCase(UserColumnFilters.PipingWti, Mechanism.Piping)]
        [TestCase(UserColumnFilters.FlowSlideWti, Mechanism.FlowSlide)]
        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 visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.Cohesion),
                StaticReflection.GetMemberName<Soil>(s => s.CohesionStochast),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngle),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngleStochast),
                StaticReflection.GetMemberName<Soil>(s => s.RatioCuPc),
                StaticReflection.GetMemberName<Soil>(s => s.RatioCuPcStochast),
                StaticReflection.GetMemberName<Soil>(s => s.StrengthIncreaseExponent),
                StaticReflection.GetMemberName<Soil>(s => s.StrengthIncreaseExponentStochast),
                StaticReflection.GetMemberName<Soil>(s => s.POP),
                StaticReflection.GetMemberName<Soil>(s => s.POPStochast),
                StaticReflection.GetMemberName<Soil>(s => s.ShearStrengthModel),
                StaticReflection.GetMemberName<Soil>(s => s.UsePop),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD70),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD70Stochast),
                StaticReflection.GetMemberName<Soil>(s => s.PermeabKx),
                StaticReflection.GetMemberName<Soil>(s => s.PermeabKxStochast),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD15),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD50),
                StaticReflection.GetMemberName<Soil>(s => s.Porosity),
                StaticReflection.GetMemberName<Soil>(s => s.MinPorosity),
                StaticReflection.GetMemberName<Soil>(s => s.MaxPorosity),
                StaticReflection.GetMemberName<Soil>(s => s.Evoldm),
                StaticReflection.GetMemberName<Soil>(s => s.Ks0),
                StaticReflection.GetMemberName<Soil>(s => s.GammaKorrel),
                StaticReflection.GetMemberName<Soil>(s => s.ParM),
                StaticReflection.GetMemberName<Soil>(s => s.ParU),
                StaticReflection.GetMemberName<Soil>(s => s.ParV),
                StaticReflection.GetMemberName<Soil>(s => s.ParR),
                StaticReflection.GetMemberName<Soil>(s => s.ParS2),
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(null, visibleProperties);
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsVisible_AdhereToFilterMacrostabilityWti()
        {
            var visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.AbovePhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.Cohesion),
                StaticReflection.GetMemberName<Soil>(s => s.CohesionStochast),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngle),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngleStochast),
                StaticReflection.GetMemberName<Soil>(s => s.RatioCuPc),
                StaticReflection.GetMemberName<Soil>(s => s.RatioCuPcStochast),
                StaticReflection.GetMemberName<Soil>(s => s.StrengthIncreaseExponent),
                StaticReflection.GetMemberName<Soil>(s => s.StrengthIncreaseExponentStochast),
                StaticReflection.GetMemberName<Soil>(s => s.POP),
                StaticReflection.GetMemberName<Soil>(s => s.POPStochast),
                StaticReflection.GetMemberName<Soil>(s => s.ShearStrengthModel),
                StaticReflection.GetMemberName<Soil>(s => s.UsePop)
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(UserColumnFilters.MacrostabilityWti, visibleProperties);
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsEnabled_AdhereToFilterMacrostabilityWti()
        {
            var context = SetupDSoilModelContext(UserColumnFilters.MacrostabilityWti);
            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(true, context.IsEnabled(soil, soil.GetMemberName(s => s.UsePop)));
            Assert.AreEqual(true, 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)));

            soil.ShearStrengthModel = ShearStrengthModel.CuCalculated;
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.Cohesion)));
            Assert.AreEqual(true, 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(true, context.IsEnabled(soil, soil.GetMemberName(s => s.RatioCuPc)));
            Assert.AreEqual(true, context.IsEnabled(soil, soil.GetMemberName(s => s.StrengthIncreaseExponent)));
            soil.UsePop = false;
            Assert.AreEqual(true, 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_AdhereToFilterPipingWti()
        {
            var visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevel),
                StaticReflection.GetMemberName<Soil>(s => s.BelowPhreaticLevelStochast),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD70),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD70Stochast),
                StaticReflection.GetMemberName<Soil>(s => s.PermeabKx),
                StaticReflection.GetMemberName<Soil>(s => s.PermeabKxStochast),
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(UserColumnFilters.PipingWti, visibleProperties);
        }

        [Test]
        public void DSoilModelContext_SoilMemberIsVisible_AdhereToFilterFlowslideWti()
        {
            var visibleProperties = new List<string>
            {
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD15),
                StaticReflection.GetMemberName<Soil>(s => s.DiameterD50),
                StaticReflection.GetMemberName<Soil>(s => s.FrictionAngle),
                StaticReflection.GetMemberName<Soil>(s => s.Porosity),
                StaticReflection.GetMemberName<Soil>(s => s.MinPorosity),
                StaticReflection.GetMemberName<Soil>(s => s.MaxPorosity),
                StaticReflection.GetMemberName<Soil>(s => s.Evoldm),
                StaticReflection.GetMemberName<Soil>(s => s.Ks0),
                StaticReflection.GetMemberName<Soil>(s => s.GammaKorrel),
                StaticReflection.GetMemberName<Soil>(s => s.ParM),
                StaticReflection.GetMemberName<Soil>(s => s.ParU),
                StaticReflection.GetMemberName<Soil>(s => s.ParV),
                StaticReflection.GetMemberName<Soil>(s => s.ParR),
                StaticReflection.GetMemberName<Soil>(s => s.ParS2),
            };
            visibleProperties.AddRange(alwaysVisibleProperties);

            AdhereToFilter(UserColumnFilters.FlowSlideWti, 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);
        }

        [TestCase("AbovePhreaticLevel")]
        [TestCase("BelowPhreaticLevel")]
        [TestCase("Cohesion")]
        [TestCase("FrictionAngle")]
        [TestCase("DiameterD70")]
        [TestCase("PermeabKx")]
        [TestCase("StrengthIncreaseExponent")]
        [TestCase("RatioCuPc")]
        [TestCase("POP")]
        public void DSoilModelContext_ParameterViewForSoil_VisibleEnabled(string memberName)
        {
            var dSoilModelContext = SetupDSoilModelContext(null);
            var soil = new Soil();
            var stochastName = memberName + "Stochast";

            dSoilModelContext.ParameterView = ParameterViewSettings.AllParameters;
            Assert.AreEqual(true, dSoilModelContext.IsVisible(soil, memberName));
            Assert.AreEqual(true, dSoilModelContext.IsVisible(soil, stochastName));
            Assert.AreEqual(true, dSoilModelContext.IsEnabled(soil, memberName));
            Assert.AreEqual(true, dSoilModelContext.IsEnabled(soil, stochastName));

            dSoilModelContext.ParameterView = ParameterViewSettings.AsIsParameters;
            Assert.AreEqual(true, dSoilModelContext.IsVisible(soil, memberName));
            Assert.AreEqual(false, dSoilModelContext.IsVisible(soil, stochastName));
            Assert.AreEqual(true, dSoilModelContext.IsEnabled(soil, memberName));
            Assert.AreEqual(false, dSoilModelContext.IsEnabled(soil, stochastName));
            
            dSoilModelContext.ParameterView = ParameterViewSettings.ProbabilisticParameters;
            Assert.AreEqual(false, dSoilModelContext.IsVisible(soil, memberName));
            Assert.AreEqual(true, dSoilModelContext.IsVisible(soil, stochastName));
            Assert.AreEqual(false, dSoilModelContext.IsEnabled(soil, memberName));
            Assert.AreEqual(true, dSoilModelContext.IsEnabled(soil, stochastName));
        }

        [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"));
            }
        }

        [Test]
        public void DSoilModelContext_GetFormat()
        {
            var dSoilModelContext = SetupDSoilModelContext(null);

            Assert.AreEqual("F3", dSoilModelContext.GetFormat(typeof(ConePenetrationTestPerSegment), null, "Xlocal"));
            Assert.AreEqual("F3", dSoilModelContext.GetFormat(null, new ConePenetrationTestPerSegment(), "Xlocal"));

            Assert.AreEqual("F3", dSoilModelContext.GetFormat(typeof(BoringPerSegment), null, "Xlocal"));
            Assert.AreEqual("F3", dSoilModelContext.GetFormat(null, new BoringPerSegment(), "Xlocal"));
        }

        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);
            isVisible = dSoilModelContext.IsVisible(sp1, sp1.GetMemberName(x => x.Location));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
        }

        [Test]
        public void TestSoilProfile2DVisibility()
        {
            var dSoilModelContext = SetupDSoilModelContext(null);
            var sp2 = new SoilProfile2D();

            var isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.XBegin));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.XEnd));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.YBegin));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.YEnd));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.Length));
            Assert.IsTrue(isVisible != null && !isVisible.Value);

            isVisible = dSoilModelContext.IsVisible(sp2, sp2.GetMemberName(p => p.Location));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
        }

        // Note: this is a temporary check as the property has to be visible in the end, only invisible for now See DSB-538
        [Test]
        public void TestSoilSegmentSettlementZonesVisibility()
        {
            var dSoilModelContext = SetupDSoilModelContext(null);
            var seg = new SoilSegment();

            var isVisible = dSoilModelContext.IsVisible(seg, seg.GetMemberName(p => p.CreateSettlementZones));
            Assert.IsTrue(isVisible != null && !isVisible.Value);
        }

        [TestCase("GeometryPointsGridViewControl", "AddRowCommand", false)]
        [TestCase("GeometryCurvesGridViewControl", "AddRowCommand", false)]
        public void IsVisibleTest_GridViewControl(string gridViewControlName, string memberName, bool expectedVisible)
        {
            var context = new DSoilModelContext();
            var grid = new GridViewControl { Name = gridViewControlName };
            Assert.AreEqual(expectedVisible, context.IsVisible(grid, memberName));
        }

        [TestCase("CptsGridViewControl", "EditCommand", false)]
        [TestCase("BoringsGridViewControl", "EditCommand", false)]
        [TestCase("CptsGridViewControl", "CopyCommand", false)]
        [TestCase("BoringsGridViewControl", "CopyCommand", false)]
        [TestCase("CptsGridViewControl", "PasteCommand", false)]
        [TestCase("BoringsGridViewControl", "PasteCommand", false)]
        [TestCase("BoringsTable", "EditCommand", false)]
        [TestCase("CPTsTable", "EditCommand", false)]
        [TestCase("BoringsTable", "PasteCommand", false)]
        [TestCase("CPTsTable", "PasteCommand", false)]
        [TestCase("SoilSegmentsTable", "AddRowCommand", false)]
        [TestCase("SoilSegmentsTable", "InsertRowCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "AddRowCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "InsertRowCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "DeleteRowCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "CopyCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "PasteCommand", false)]
        [TestCase("SurfaceLinePointsGridControl", "EditCommand", false)]
        [TestCase("SurfaceLinesTable", "AddRowCommand", false)]
        [TestCase("SurfaceLinesTable", "InsertRowCommand", false)]
        public void IsEnabledTest_GridViewControl(string gridViewControlName, string memberName, bool expectedEnabled)
        {
            var context = new DSoilModelContext();
            var grid = new GridViewControl { Name = gridViewControlName };
            Assert.AreEqual(expectedEnabled, context.IsEnabled(grid, memberName));
        }

        [TestCase(typeof(CharacteristicPoint), "X", false)]
        [TestCase(typeof(CharacteristicPoint), "Z", false)]
        public void IsEnabledTest(Type senderType, string memberName, bool? expectedVisible)
        {
            var sender = Activator.CreateInstance(senderType);
            var context = new DSoilModelContext();
            Assert.AreEqual(expectedVisible, context.IsEnabled(sender, memberName));
        }

        [TestCase(typeof(ConePenetrationTestData))]
        [TestCase(typeof(Boring))]
        public void DisableDeletingSelectedObjectInGeometryEditor(Type selectedType)
        {
            var geometryEditor = new GeometryEditor();
            var context = new DSoilModelContext();
            
            // response depends on selected object in geometry editor
            Assert.AreEqual(null, context.IsEnabled(geometryEditor, "DeleteSelectedObjects"));

            var selection = Activator.CreateInstance(selectedType);
            geometryEditor.SpatialEditor.EmptySelection = new Shape { DataObject = selection };
            
            Assert.AreEqual(false, context.IsEnabled(geometryEditor, "DeleteSelectedObjects"));
        }

        [Test]
        public void HideImportOldDatabaseCommand()
        {
            var context = new DSoilModelContext();
            var plugin = new DSoilModelPlugin();

            Assert.AreEqual(false, context.IsVisible(plugin, "OldProjectImport"));
        }
    }
}