/// <summary>
        /// Parses the wiki tree.
        /// </summary>
        /// <param name="url">Base URL.</param>
        /// <returns>Tree.</returns>
        private RockClimbingComWikiTree ParseTree(string url)
        {
            RockClimbingComWikiNode n = null;
            RockClimbingComWikiTree ret = new RockClimbingComWikiTree();

            ret.Parent = null;
            ret.SectorNodes = new List<RockClimbingComWikiNode>();

            n = ParseTreeRecursive(url, ret);

            if (n != null)
            {
                ret.Info = n.Info;
                ret.Routes = n.Routes;
                ret.ChildNodes = n.ChildNodes;
            }

            return ret;
        }
        /// <summary>
        /// Parses the wiki tree structure.
        /// </summary>
        /// <param name="url">Target URL.</param>
        /// <param name="root">Root tree.</param>
        /// <returns>Tree structure.</returns>
        private RockClimbingComWikiNode ParseTreeRecursive(string url, RockClimbingComWikiTree root)
        {
            string content = string.Empty;
            RockClimbingComWikiNode ret = null;
            RockClimbingComWikiNode child = null;

            if (!string.IsNullOrEmpty(url))
            {
                Trace("Tree node: {0}", Prettify(url));

                content = Load(url);

                if (!string.IsNullOrEmpty(content))
                {
                    ret = new RockClimbingComWikiNode();

                    ret.Contents = new List<string>(new string[] { content });
                    ret.Info = RockClimbingComWiki.Parse(content);
                    ret.Routes = ParseRoutes(content);

                    ret.ChildNodes = new List<RockClimbingComWikiNode>();

                    // Trying to mark node as sector node
                    root.SectorNodes.Add(ret);

                    foreach (RockClimbingComListItem item in GetListItems(content))
                    {
                        if (item.Total > 0)
                        {
                            child = ParseTreeRecursive(item.Url, root);

                            if (child != null)
                            {
                                child.Parent = ret;
                                ret.ChildNodes.Add(child);
                            }
                        }
                    }

                    // Node has no routes - removing from sector nodes
                    if (ret.Routes == null || !ret.Routes.Any())
                        root.SectorNodes.Remove(ret);
                }
            }

            return ret;
        }
        /// <summary>
        /// Converts the given tree to areas.
        /// </summary>
        /// <param name="tree">Tree to convert.</param>
        /// <param name="tags">Parent tags, if any.</param>
        private void ConvertTreeToAreas(RockClimbingComWikiTree tree, IEnumerable<string> tags)
        {
            int order = 0;
            ParsedArea area = null;
            ParsedSector sector = null;
            IList<string> areaTags = null;
            IList<string> sectorTags = null;
            RockClimbingComWiki areaWiki = null;
            RockClimbingComWikiNodeBase accumulatedSector = null;
            Dictionary<string, ParsedArea> areas = new Dictionary<string, ParsedArea>();

            if (tree != null && tree.SectorNodes.Any())
            {
                // Traversing only sector nodes - nodes where we found routes
                foreach (RockClimbingComWikiNode actualSector in tree.SectorNodes)
                {
                    // Accumulating details and routes
                    accumulatedSector = actualSector.AccumulateAll();

                    // Accumulating details for area
                    if (actualSector.Parent != null)
                        areaWiki = actualSector.Parent.AccumulateWiki();
                    else
                        areaWiki = actualSector.AccumulateWiki();

                    // Accumulating tags for area and sector
                    sectorTags = actualSector.GetTags(tags);

                    if (actualSector.Parent != null)
                        areaTags = actualSector.Parent.GetTags(tags);
                    else
                        areaTags = new List<string>(sectorTags);

                    if (accumulatedSector != null && areaWiki != null)
                    {
                        sector = new ParsedSector();

                        if (accumulatedSector.Info != null)
                        {
                            sector.Name = accumulatedSector.Info.Name;
                            sector.Description = accumulatedSector.Info.Description;
                            sector.Climbing = accumulatedSector.Info.Climbing;
                            sector.Location = accumulatedSector.Info.Location;
                            sector.Season = accumulatedSector.Info.Season;
                            sector.Origin = "http://rockclimbing.com";
                            sector.Tags = sectorTags;
                            sector.Order = (++order);
                        }

                        // Assigning all routes from the tree
                        sector.Routes = accumulatedSector.Routes;

                        // Getting image
                        if (accumulatedSector.Contents != null && accumulatedSector.Contents.Any())
                        {
                            foreach (string sectorContent in accumulatedSector.Contents)
                            {
                                sector.Image = ParseImage(sectorContent);

                                if (sector.Image != null && sector.Image.Any())
                                    break;
                            }
                        }

                        if (!areas.ContainsKey(areaWiki.Name))
                        {
                            area = new ParsedArea();

                            area.Name = areaWiki.Name;
                            area.Description = areaWiki.Description;
                            area.Climbing = areaWiki.Climbing;
                            area.Location = areaWiki.Location;
                            area.Season = areaWiki.Season;
                            area.Origin = "http://rockclimbing.com";
                            area.Tags = areaTags;

                            areas.Add(areaWiki.Name, area);
                        }

                        if (areas[areaWiki.Name].Sectors == null)
                            areas[areaWiki.Name].Sectors = new List<ParsedSector>();

                        if (sector.Routes != null && sector.Routes.Any())
                        {
                            // Adding sector to area
                            areas[areaWiki.Name].Sectors.Add(sector);
                        }
                    }
                }

                foreach (ParsedArea a in areas.Values)
                {
                    if (a.Sectors != null && a.Sectors.Any())
                        OnAreaParsed(a);
                }
            }
        }