using Autodesk.Revit.Attributes;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using EditSchedulesTool.Utils;
using System.Linq;

namespace EditSchedulesTool
{
    [Transaction(TransactionMode.Manual)]
    public class Cmd_Test : IExternalCommand
    {
        private UIDocument _uidoc;
        private Document _doc;

        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            _uidoc = commandData.Application.ActiveUIDocument;
            _doc = _uidoc.Document;
            Dojob();
            return Result.Cancelled;
        }

        private void Dojob()
        {
            ElementId paramId = GetParameterId("test_weight");
            if (paramId != null && paramId != ElementId.InvalidElementId)
            {
                FilterRule rule = CreateFilterRule(paramId, StorageType.Double, "0", 1e-9);
                ElementParameterFilter filter = new ElementParameterFilter(rule);

                var ids = new FilteredElementCollector(_doc)
                                .WhereElementIsNotElementType()
                                .OfCategory(BuiltInCategory.OST_Walls)
                                .WherePasses(filter)
                                .ToElementIds();

                if (ids?.Count > 0)
                {
                    _uidoc.Selection.SetElementIds(ids);
                    Common.ShowInfo("finished");
                    return;
                }
                else
                    Common.ShowWarning("elem not found");
            }
            else
                Common.ShowWarning("paramter not found");
        }

        private ElementId GetParameterId(string name)
        {
            if (!string.IsNullOrEmpty(name))
            {
                var elem = new FilteredElementCollector(_doc)
                                .WhereElementIsNotElementType()
                                .OfClass(typeof(ParameterElement))
                                .FirstOrDefault(x => x.Name.Equals(name));

                if (elem != null && elem is ParameterElement paramElem)
                    return paramElem.GetDefinition().Id;
            }
            return null;
        }

        private FilterRule CreateFilterRule(ElementId paramId,
                                           StorageType storageType,
                                           string textValue,
                                           double tolerance)
        {
            FilterRule rule = null;
            ParameterValueProvider provider = new NumericalFilterableValueProvider(_doc, paramId);
            FilterNumericEquals numberEval = new FilterNumericEquals();
            FilterStringRuleEvaluator stringEval = new FilterStringEquals();

            switch (storageType)
            {
                case StorageType.Integer:
                    if (int.TryParse(textValue, out int ival))
                        rule = new FilterIntegerRule(provider, numberEval, ival);
                    break;

                case StorageType.Double:
                    if (double.TryParse(textValue, out double dVal))
                        rule = new FilterDoubleRule(provider, numberEval, dVal, tolerance);
                    break;

                case StorageType.String:
                    rule = new FilterStringRule(provider, stringEval, textValue, true);
                    break;

                case StorageType.ElementId:
                    //var elemsFound = new FilteredElementCollector(_doc, _doc.ActiveView.Id)
                    //                    .WhereElementIsElementType()
                    //                    .ToElements()
                    //                    .FirstOrDefault<Element>(e => e.Name == textValue);
                    //if (elemsFound != null)
                    //    rule = new FilterElementIdRule(provider, numberEval, elemsFound.Id);
                    break;
            }
            return rule;
        }
    }

    /// <summary>
    /// derived class to extract default value for 
    /// parameter in case it does not has a value
    /// </summary>
    public class NumericalFilterableValueProvider : ParameterValueProvider
    {
        private string _paramName;

        public NumericalFilterableValueProvider(Document doc, ElementId paramId)
            : base(paramId)
        {
            _paramName = Common.GetParameterName(doc, paramId);
        }

        public new int GetIntegerValue(Element element)
        {
            if (!string.IsNullOrEmpty(_paramName))
            {
                Parameter param = element.LookupParameter(_paramName);
                if (param != null )
                    return param.AsInteger();
            }
            return 0;
        }

        public new double GetDoubleValue(Element element)
        {
            if (!string.IsNullOrEmpty(_paramName))
            {
                Parameter param = element.LookupParameter(_paramName);
                if (param != null)
                    return param.AsDouble();
            }
            return 0;
        }
    }
}