using System.Linq;
using System.Reflection;
using Autodesk.DesignScript.Runtime;
using Autodesk.Revit.DB;
using Revit.Elements;
using dynCategory = Revit.Elements.Category;
using dynDocument = Revit.Application.Document;
using dynElement = Revit.Elements.Element;
using dynElementSelector = Revit.Elements.ElementSelector;
using dynFamilyDocument = Revit.Application.FamilyDocument;
using dynFamilyParameter = Revit.Elements.FamilyParameter;
using dynFilterRule = Revit.Filter.FilterRule;
using dynParameter = Revit.Elements.Parameter;
using dynParameterFilterElement = Revit.Filter.ParameterFilterElement;
using iDocument = Orchid.RevitProject.Common.Document;
using rvtCategory = Autodesk.Revit.DB.Category;
using rvtDocument = Autodesk.Revit.DB.Document;
using rvtElement = Autodesk.Revit.DB.Element;
using rvtFamilyParameter = Autodesk.Revit.DB.FamilyParameter;
using rvtFilterRule = Autodesk.Revit.DB.FilterRule;
using rvtParameter = Autodesk.Revit.DB.Parameter;
using rvtParameterFilterElement = Autodesk.Revit.DB.ParameterFilterElement;

namespace SomeNamespace
{
    [IsVisibleInDynamoLibrary(false)]
    internal static class Convert
    {
        private static rvtDocument _document;

        #region Document converters
        internal static dynDocument ToDynamoType(this rvtDocument item)
        {
            var constructor = typeof(dynDocument).GetConstructors(
                BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();

            return constructor.Invoke(new object[] { item }) as dynDocument;
        }

        internal static dynFamilyDocument ToFamilyDocument(this rvtDocument item)
        {
            return dynFamilyDocument.ByDocument(item.ToDynamoType());
        }

        internal static rvtDocument ToRevitType(this dynDocument item)
        {
            var property = typeof(dynDocument).GetProperty("InternalDocument",
                BindingFlags.NonPublic | BindingFlags.Instance);

            return property.GetValue(item) as rvtDocument;
        }
        #endregion Document converters


        #region Category converters
        internal static dynCategory ToDynamoType(this rvtCategory item)
        {
            return dynCategory.ById(item.Id.IntegerValue);
        }

        internal static rvtCategory ToRevitType(this dynCategory item)
        {
            _document = iDocument.InitGenericDocument();
            var id = new ElementId(item.Id);
            return rvtCategory.GetCategory(_document, id);
        }

        internal static rvtCategory ToRevitType(this dynCategory item, rvtDocument document)
        {
            var id = new ElementId(item.Id);
            return rvtCategory.GetCategory(document, id);
        }
        #endregion Category converters


        #region Parameter converters
        internal static dynParameter ToDynamoType(this rvtParameter item)
        {
            var constructor = typeof(dynParameter).GetConstructors(
                BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();

            return constructor.Invoke(new object[] { item }) as dynParameter;
        }

        internal static rvtParameter ToRevitType(this dynParameter item)
        {
            var property = typeof(dynParameter).GetProperty("InternalParameter",
                BindingFlags.NonPublic | BindingFlags.Instance);

            return property.GetValue(item) as rvtParameter;
        }
        #endregion Parameter converters


        #region FamilyParameter converters
        internal static dynFamilyParameter ToDynamoType(this rvtFamilyParameter item)
        {
            var constructor = typeof(dynFamilyParameter).GetConstructors(
                BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();

            return constructor.Invoke(new object[] { item }) as dynFamilyParameter;
        }

        internal static rvtFamilyParameter ToRevitType(this dynFamilyParameter item)
        {
            var property = typeof(dynFamilyParameter).GetProperty("InternalFamilyParameter",
                BindingFlags.NonPublic | BindingFlags.Instance);

            return property.GetValue(item) as rvtFamilyParameter;
        }
        #endregion FamilyParameter converters


        #region Element converters
        internal static dynElement ToDynamoType(this ElementId item)
        {
            return dynElementSelector.ByElementId(item.IntegerValue);
        }

        internal static dynElement ToDynamoType(this int item)
        {
            return dynElementSelector.ByElementId(item);
        }

        internal static dynElement ToDynamoType(this rvtElement item)
        {
            return item.ToDSType(true);
        }

        internal static rvtElement ToRevitType(this dynElement item)
        {
            return item.InternalElement;
        }

        internal static rvtElement ToRevitType(this ElementId item)
        {
            _document = iDocument.InitGenericDocument();
            return _document.GetElement(item);
        }

        internal static rvtElement ToRevitType(this ElementId item, rvtDocument document)
        {
            return document.GetElement(item);
        }
        #endregion Element converters


        #region Filter rule converters
        internal static dynFilterRule ToDynamoType(this rvtFilterRule item)
        {
            var constructor = typeof(dynFilterRule).GetConstructors(
                BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();

            return constructor.Invoke(new object[] { item }) as dynFilterRule;
        }

        internal static rvtFilterRule ToRevitType(this dynFilterRule item)
        {
            var property = typeof(dynFilterRule).GetProperty("InternalFilterRule",
                BindingFlags.NonPublic | BindingFlags.Instance);

            return property.GetValue(item) as rvtFilterRule;
        }

        internal static dynParameterFilterElement ToDynamoType(this rvtParameterFilterElement item)
        {
            var constructor = typeof(dynParameterFilterElement).GetConstructors(
                BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();

            return constructor.Invoke(new object[] { item }) as dynParameterFilterElement;
        }

        internal static rvtParameterFilterElement ToRevitType(this dynParameterFilterElement item)
        {
            var property = typeof(dynParameterFilterElement).GetProperty("InternalRevitElement",
                BindingFlags.NonPublic | BindingFlags.Instance);

            return property.GetValue(item) as ParameterFilterElement;
        }
        #endregion Filter rule converters

    }
}