/// <summary>
 /// Creates an instance of <cref name="CompactBubbleViewModel"/> class
 /// from given node value
 /// </summary>
 /// <param name="value">Node value</param>
 /// <returns>Instance of <cref name="CompactBubbleViewModel"/> class</returns>
 public static CompactBubbleViewModel Process(MirrorData value)
 {
     items = 0;
     var viewModel = ProcessThing(value, true);
     viewModel.NumberOfItems = items;
     return viewModel;
 }

        internal WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData)
        {
            if (data.IsCollection)
            {
                var list = data.GetElements();

                var node = new WatchViewModel(visualizationManager, list.Count == 0 ? "Empty List" : "List", tag, true);
                foreach (var e in list.Select((element, idx) => new { element, idx }))
                {
                    node.Children.Add(ProcessThing(e.element, tag + ":" + e.idx, showRawData));
                }

                return node;
            }
            
            // MAGN-3494: If "data.Data" is null, then return a "null" string 
            // representation instead of casting it as dynamic (that leads to 
            // a crash).
            if (data.IsNull || data.Data == null)
                return new WatchViewModel(visualizationManager, NULL_STRING, tag);

            //If the input data is an instance of a class, create a watch node
            //with the class name and let WatchHandler process the underlying CLR data
            var classMirror = data.Class;
            if (null != classMirror)
            {
                if (data.Data == null && !data.IsNull) //Must be a DS Class instance.
                    return ProcessThing(classMirror.ClassName, tag, showRawData); //just show the class name.
                return Process(data.Data, tag, showRawData);
            }

            //Finally for all else get the string representation of data as watch content.
            return Process(data.Data, tag, showRawData);
        }

 /// <summary>
 /// This consutructor is for instantiating a Runtime mirror object where we already have the mirrorData
 /// </summary>
 /// <param name="mirrorData"></param>
 /// <param name="core"></param>
 public RuntimeMirror(MirrorData mirrorData, ProtoCore.Core core, ProtoCore.Core staticCore = null) : base(core, staticCore)
 {
     Validity.Assert(this.core != null);
     TargetExecutive = core.CurrentExecutive.CurrentDSASMExec;
     deprecateThisMirror = new DSASM.Mirror.ExecutionMirror(TargetExecutive, core);
     this.mirrorData = mirrorData;
 }

 /// <summary>
 /// This consutructor is for instantiating a Runtime mirror object where we already have the mirrorData
 /// </summary>
 /// <param name="mirrorData"></param>
 /// <param name="core"></param>
 public RuntimeMirror(MirrorData mirrorData, ProtoCore.RuntimeCore runtimeCoreReflect, ProtoCore.Core staticCore = null)
     : base(runtimeCoreReflect, staticCore)
 {
     Validity.Assert(this.runtimeCore != null);
     TargetExecutive = runtimeCoreReflect.CurrentExecutive.CurrentDSASMExec;
     deprecateThisMirror = new DSASM.Mirror.ExecutionMirror(TargetExecutive, runtimeCoreReflect);
     this.mirrorData = mirrorData;
 }

 internal WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData)
 {
     try
     {
         return baseHandler.Process(data, tag, showRawData);
     }
     catch (Exception)
     {
         return Process(data.Data, tag, showRawData);
     }
 }

 private WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData, WatchHandlerCallback callback)
 {
     try
     {
         return baseHandler.Process(data, tag, showRawData, callback);
     }
     catch (Exception)
     {
         return callback(data.Data, tag, showRawData);
     }
 }

 /// <summary>
 /// Validates the watch content with given mirror data.
 /// </summary>
 /// <param name="watch">WatchViewModel of the watch node</param>
 /// <param name="mirrorData">MirrorData to be shown in watch</param>
 private void AssertWatchContent(WatchViewModel watch, MirrorData mirrorData)
 {
     Assert.IsNotNull(mirrorData);
     if (mirrorData.IsCollection)
         AssertWatchTreeBranchContent(watch.Children, mirrorData.GetElements());
     else if (mirrorData.IsNull)
         Assert.AreEqual("null", watch.NodeLabel);
     else
     {
         string nodeLabel = string.Format("{0}", mirrorData.Data);
         Assert.AreEqual(nodeLabel, watch.NodeLabel);
     }
 }

 public void AssertValue(MirrorData data, object value)
 {
     if (data.IsCollection)
         AssertCollection(data, value as IEnumerable);
     else if (value == null)
         Assert.IsTrue(data.IsNull);
     else if (value is int)
         Assert.AreEqual((int)value, Convert.ToInt32(data.Data));
     else if (value is double)
         Assert.AreEqual((double)value, Convert.ToDouble(data.Data), 0.00001);
     else
         Assert.AreEqual(value, data.Data);
 }

            public RuntimeMirror(string varname, int blockDecl, ProtoCore.RuntimeCore runtimeCore, ProtoCore.Core staticCore = null)
                : base(runtimeCore, staticCore)
            {
                TargetExecutive = runtimeCore.CurrentExecutive.CurrentDSASMExec;
                deprecateThisMirror = new DSASM.Mirror.ExecutionMirror(TargetExecutive, runtimeCore);

                Validity.Assert(this.runtimeCore != null);

                variableName = varname;
                blockDeclaration = blockDecl;
                StackValue svData = deprecateThisMirror.GetValue(variableName, blockDeclaration).DsasmValue;

                mirrorData = new MirrorData(staticCore, this.runtimeCore, svData);
            }

        internal WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData = true)
        {
            //If the input data is an instance of a class, create a watch node
            //with the class name and let WatchHandler process the underlying CLR data
            var classMirror = data.Class;
            if (null != classMirror)
            {
                if (data.Data == null && !data.IsNull) //Must be a DS Class instance.
                    return ProcessThing(classMirror.ClassName, tag); //just show the class name.
                return ProcessThing(data.Data as dynamic, tag, showRawData);
            }

            //Finally for all else get the string representation of data as watch content.
            return ProcessThing(data.Data as dynamic, tag);
        }

        /// <summary>
        /// Counts the number of all collection items of node output and if specified 
        /// it generates appropriate view model for compact preview bubble
        /// </summary>
        /// <param name="mirrorData">Data which represents the value of node output</param>
        /// <param name="generateViewModel">Flag to not create unused view models</param>
        /// <returns><cref name="CompactBubbleViewModel"/> instance 
        /// if <paramref name="generateViewModel"/> is specified. Otherwise, null</returns>
        private static CompactBubbleViewModel ProcessThing(MirrorData mirrorData, bool generateViewModel)
        {
            if (mirrorData == null)
            {
                return generateViewModel ? new CompactBubbleViewModel(Resources.NullString, 0) : null;
            }

            if (mirrorData.IsCollection)
            {
                var list = mirrorData.GetElements();

                foreach (var item in list)
                {
                    ProcessThing(item, false);
                }

                return generateViewModel
                    ? new CompactBubbleViewModel(true)
                    {
                        NodeLabel = list.Any() ? "List" : "Empty List"
                    }
                    : null;
            }

            items++;

            if (!generateViewModel) return null;

            var viewModel = new CompactBubbleViewModel(false);
            if (mirrorData.Data == null && !mirrorData.IsNull && mirrorData.Class != null)
            {
                viewModel.NodeLabel = mirrorData.Class.ClassName;
            }
            else if (mirrorData.Data is Enum)
            {
                viewModel.NodeLabel = ((Enum)mirrorData.Data).GetDescription();
            }
            else
            {
                // Cut StringData so that only the type name remains
                // for example, "Point (Z = 0.000, Y = 0.000, Z = 0.000)" -> "Point"
                viewModel.NodeLabel = string.IsNullOrEmpty(mirrorData.StringData)
                    ? string.Empty
                    : mirrorData.StringData.Split('(')[0];
            }

            return viewModel;
        }

        internal WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData = true)
        {
            //If the input data is an instance of a class, create a watch node
            //with the class name and let WatchHandler process the underlying CLR data
            var classMirror = data.Class;
            if (null != classMirror)
            {
                if (data.Data == null && !data.IsNull) //Must be a DS Class instance.
                    return ProcessThing(classMirror.ClassName, tag); //just show the class name.
                return ProcessThing(data.Data as dynamic, tag, showRawData);
            }

            // MAGN-3494: If "data.Data" is null, then return a "null" string 
            // representation instead of casting it as dynamic (that leads to 
            // a crash).
            if (data.Data == null)
                return new WatchViewModel("null", tag);

            //Finally for all else get the string representation of data as watch content.
            return ProcessThing(data.Data as dynamic, tag, showRawData);
        }

 private void AssertCollection(MirrorData data, IEnumerable collection)
 {
     Assert.IsTrue(data.IsCollection);
     List<MirrorData> elements = data.GetElements();
     int i = 0;
     foreach (var item in collection)
     {
         AssertValue(elements[i++], item);
     }
 }

 private void AssertMirrorData(MirrorData data1, MirrorData data2)
 {
     if (data1.IsNull)
         Assert.True(data2.IsNull);
     else if (data1.IsCollection)
     {
         Assert.True(data2.IsCollection);
         List<MirrorData> elems1 = data1.GetElements();
         List<MirrorData> elems2 = data2.GetElements();
         Assert.AreEqual(elems1.Count, elems2.Count);
         int i = 0;
         foreach (var item in elems1)
         {
             AssertMirrorData(item, elems2[i++]);
         }
     }
     else
         Assert.AreEqual(data1.Data, data2.Data);
 }

        private void SelectivelyAssertValues(MirrorData data, Dictionary<int, object> selectedValues)
        {
            Assert.IsTrue(data.IsCollection);

            if (data.IsCollection)
            {
                List<MirrorData> elements = data.GetElements();
                foreach (var pair in selectedValues)
                {
                    AssertValue(elements[pair.Key], pair.Value);
                }
            }
        }

 private void AddToSizeMap(MirrorData data, ICollection<double> map)
 {
     if (data.IsCollection)
     {
         var list = data.GetElements();
         foreach (MirrorData t in list)
         {
             AddToSizeMap(t, map);
         }
     }
     else if (data.Data is IEnumerable)
     {
         var list = data.Data as IEnumerable;
         AddToSizeMap(list, map);
     }
     else
     {
         map.Add(ComputeBBoxDiagonalSize(data.Data));
     }
 }

        private static void GetGraphicItemsFromMirrorData(MirrorData mirrorData, List<IGraphicItem> graphicItems)
        {
            if (mirrorData == null) return;

            if (mirrorData.IsCollection)
            {
                foreach (var el in mirrorData.GetElements())
                {
                    GetGraphicItemsFromMirrorData(el, graphicItems);
                }
            }
            else
            {
                var graphicItem = mirrorData.Data as IGraphicItem;
                if (graphicItem == null) return;

                graphicItems.Add(graphicItem);
            }
        }

        /// <summary>
        /// Convert mirror data objects for nodes to Revit types.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="geoms"></param>
        private void RevitGeometryFromMirrorData(MirrorData data, ref List<GeometryObject> geoms)
        {
            if (data.IsCollection)
            {
                foreach (var md in data.GetElements())
                {
                    try
                    {
                        RevitGeometryFromMirrorData(md, ref geoms);
                    }
                    catch (Exception ex)
                    {
                        this.dynamoModel.Logger.Log(ex.Message);
                    }
                }
            }
            else
            {
                try
                {
                    var geom = data.Data as PolyCurve;
                    if (geom != null)
                    {
                        geoms.AddRange(geom.ToRevitType());
                        return;
                    }

                    var point = data.Data as Point;
                    if (point != null)
                    {
                        geoms.Add(DocumentManager.Instance.CurrentUIApplication.Application.Create.NewPoint(point.ToXyz()));
                        return;
                    }

                    var curve = data.Data as Curve;
                    if (curve != null)
                    {
                        geoms.Add(curve.ToRevitType());
                        return;
                    }
                }
                catch (Exception ex)
                {
                    this.dynamoModel.Logger.Log(ex.Message);
                }
            }
        }

        private void OnNodeValueQueried(AsyncTask asyncTask)
        {
            lock (cachedMirrorDataMutex)
            {
                var task = asyncTask as QueryMirrorDataAsyncTask;
                cachedMirrorData = task.MirrorData;
            }

            RaisePropertyChanged("IsUpdated");
        }

        /// <summary>
        /// Call this method to asynchronously update the cached MirrorData for 
        /// this NodeModel through DynamoScheduler. AstIdentifierForPreview is 
        /// being accessed within this method, therefore the method is typically
        /// called from the main/UI thread.
        /// </summary>
        /// 
        internal void RequestValueUpdateAsync(IScheduler scheduler, EngineController engine)
        {
            // A NodeModel should have its cachedMirrorData reset when it is 
            // requested to update its value. When the QueryMirrorDataAsyncTask 
            // returns, it will update cachedMirrorData with the latest value.
            // 
            lock (cachedMirrorDataMutex)
            {
                cachedMirrorData = null;
            }

            // Do not have an identifier for preview right now. For an example,
            // this can be happening at the beginning of a code block node creation.
            var variableName = AstIdentifierForPreview.Value;
            if (string.IsNullOrEmpty(variableName))
                return;

            var task = new QueryMirrorDataAsyncTask(new QueryMirrorDataParams
            {
                Scheduler = scheduler,
                EngineController = engine,
                VariableName = variableName
            });

            task.Completed += OnNodeValueQueried;
            scheduler.ScheduleForExecution(task);
        }