//------------------------------------------------------------------------------
// <copyright file="SiteMapProvider.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

/*
 * Copyright (c) 2002 Microsoft Corporation
 */
namespace System.Web {

    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Configuration.Provider;
    using System.Web.Security;
    using System.Web.UI;
    using System.Web.Util;
    using System.Security.Permissions;

    public abstract class SiteMapProvider : ProviderBase {

        private bool _securityTrimmingEnabled;
        private bool _enableLocalization;
        private String _resourceKey;

        internal const String _securityTrimmingEnabledAttrName = "securityTrimmingEnabled";
        private const string _allRoles = "*";

        private SiteMapProvider _rootProvider;
        private SiteMapProvider _parentProvider;
        private object _resolutionTicket = new object();

        internal readonly object _lock = new Object();

        public virtual SiteMapNode CurrentNode {
            get {
                HttpContext context = HttpContext.Current;
                SiteMapNode result = null;

                // First check the SiteMap resolve events.
                result = ResolveSiteMapNode(context);

                if (result == null) {
                    result = FindSiteMapNode(context);
                }

                return ReturnNodeIfAccessible(result);
            }
        }

        public bool EnableLocalization {
            get {
                return _enableLocalization;
            }
            set {
                _enableLocalization = value;
            }
        }

        // Parent provider
        public virtual SiteMapProvider ParentProvider {
            get {
                return _parentProvider;
            }
            set {
                _parentProvider = value;
            }
        }

        public string ResourceKey {
            get {
                return _resourceKey;
            }
            set {
                _resourceKey = value;
            }
        }

        public virtual SiteMapProvider RootProvider {
            get {
                if (_rootProvider == null) {
                    lock (_lock) {
                        if (_rootProvider == null) {
                            Hashtable providers = new Hashtable();
                            SiteMapProvider candidate = this;

                            providers.Add(candidate, null);
                            while (candidate.ParentProvider != null) {
                                if (providers.Contains(candidate.ParentProvider))
                                    throw new ProviderException(SR.GetString(SR.SiteMapProvider_Circular_Provider));

                                candidate = candidate.ParentProvider;
                                providers.Add(candidate, null);
                            }

                            _rootProvider = candidate;
                        }
                    }
                }

                return _rootProvider;
            }
        }

        public virtual SiteMapNode RootNode {
            get {
                SiteMapNode node = GetRootNodeCore();
                return ReturnNodeIfAccessible(node);
            }
        }

        public bool SecurityTrimmingEnabled {
            get {
                return _securityTrimmingEnabled;
            }
        }

        public event SiteMapResolveEventHandler SiteMapResolve;

        /// <devdoc>
        ///    <para>Add single node to provider.</para>
        /// </devdoc>
        protected virtual void AddNode(SiteMapNode node) {
            AddNode(node, null);
        }

        protected internal virtual void AddNode(SiteMapNode node, SiteMapNode parentNode) {
            throw new NotImplementedException();
        }

        public virtual SiteMapNode FindSiteMapNode(HttpContext context) {
            if (context == null) {
                return null;
            }

            string rawUrl = context.Request.RawUrl;

            SiteMapNode result = null;

            // First check the RawUrl
            result = FindSiteMapNode(rawUrl);

            if (result == null) {
                int queryStringIndex = rawUrl.IndexOf("?", StringComparison.Ordinal);
                if (queryStringIndex != -1) {
                    // check the RawUrl without querystring
                    result = FindSiteMapNode(rawUrl.Substring(0, queryStringIndex));
                }

                if (result == null) {
                    Page page = context.CurrentHandler as Page;
                    if (page != null) {
                        // Try without server side query strings
                        string qs = page.ClientQueryString;
                        if (qs.Length > 0) {
                            result = FindSiteMapNode(context.Request.Path + "?" + qs);
                        }
                    }

                    if (result == null) {
                        // Check the request path
                        result = FindSiteMapNode(context.Request.Path);
                    }
                }
            }

            return result;
        }

        public virtual SiteMapNode FindSiteMapNodeFromKey(string key) {
            return FindSiteMapNode(key);
        }

        public abstract SiteMapNode FindSiteMapNode(string rawUrl);

        public abstract SiteMapNodeCollection GetChildNodes(SiteMapNode node);

        public virtual SiteMapNode GetCurrentNodeAndHintAncestorNodes(int upLevel) {
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }

            return CurrentNode;
        }

        public virtual SiteMapNode GetCurrentNodeAndHintNeighborhoodNodes(int upLevel, int downLevel) {
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }

            if (downLevel < -1) {
                throw new ArgumentOutOfRangeException("downLevel");
            }

            return CurrentNode;
        }

        public abstract SiteMapNode GetParentNode(SiteMapNode node);

        public virtual SiteMapNode GetParentNodeRelativeToCurrentNodeAndHintDownFromParent (
            int walkupLevels, int relativeDepthFromWalkup) {

            if (walkupLevels < 0) {
                throw new ArgumentOutOfRangeException("walkupLevels");
            }

            if (relativeDepthFromWalkup < 0) {
                throw new ArgumentOutOfRangeException("relativeDepthFromWalkup");
            }

            // First get current nodes and hints about its ancestors.
            SiteMapNode currentNode = GetCurrentNodeAndHintAncestorNodes(walkupLevels);

            // Simply return if the currentNode is null.
            if (currentNode == null) {
                return null;
            }

            // Find the target node by walk up the parent tree.
            SiteMapNode targetNode = GetParentNodesInternal(currentNode, walkupLevels);

            if (targetNode == null) {
                return null;
            }

            // Get hints about its lower neighborhood nodes.
            HintNeighborhoodNodes(targetNode, 0, relativeDepthFromWalkup);

            return targetNode;
        }

        public virtual SiteMapNode GetParentNodeRelativeToNodeAndHintDownFromParent(
            SiteMapNode node, int walkupLevels, int relativeDepthFromWalkup) {

            if (walkupLevels < 0) {
                throw new ArgumentOutOfRangeException("walkupLevels");
            }

            if (relativeDepthFromWalkup < 0) {
                throw new ArgumentOutOfRangeException("relativeDepthFromWalkup");
            }

            if (node == null) {
                throw new ArgumentNullException("node");
            }

            // First get hints about ancestor nodes;
            HintAncestorNodes(node, walkupLevels);

            // walk up the parent node until the target node is found.
            SiteMapNode ancestorNode = GetParentNodesInternal(node, walkupLevels);

            if (ancestorNode == null) {
                return null;
            }

            // Get hints about its neighthood nodes
            HintNeighborhoodNodes(ancestorNode, 0, relativeDepthFromWalkup);

            return ancestorNode;
        }

        private SiteMapNode GetParentNodesInternal(SiteMapNode node, int walkupLevels) {
            Debug.Assert(node != null);
            if (walkupLevels <= 0) {
                return node;
            }

            do {
                node = node.ParentNode;
                walkupLevels--;
            } while (node != null && walkupLevels != 0);

            return node;
        }

        /*
         * A reference node that must be returned by all sitemap providers, this is
         * required for the parent provider to keep track of the relations between
         * two providers.
         * For example, the parent provider uses this method to keep track of the parent
         * node of child provider's root node.
         */
        protected internal abstract SiteMapNode GetRootNodeCore();

        protected static SiteMapNode GetRootNodeCoreFromProvider(SiteMapProvider provider) {
            return provider.GetRootNodeCore();
        }

        public virtual void HintAncestorNodes(SiteMapNode node, int upLevel) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }

            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }
        }

        public virtual void HintNeighborhoodNodes(SiteMapNode node, int upLevel, int downLevel) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }

            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }

            if (downLevel < -1) {
                throw new ArgumentOutOfRangeException("downLevel");
            }
        }

        public override void Initialize(string name, NameValueCollection attributes) {
            if (attributes != null) {
                if (string.IsNullOrEmpty(attributes["description"])) {
                    attributes.Remove("description");
                    attributes.Add("description", this.GetType().Name);
                }

                ProviderUtil.GetAndRemoveBooleanAttribute(attributes, _securityTrimmingEnabledAttrName, Name, ref _securityTrimmingEnabled);
            }

            base.Initialize(name, attributes);
        }

        public virtual bool IsAccessibleToUser(HttpContext context, SiteMapNode node) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }

            if (context == null) {
                throw new ArgumentNullException("context");
            }

            if (!SecurityTrimmingEnabled) {
                return true;
            }

            if (node.Roles != null) {
                foreach (string role in node.Roles) {
                    // Grant access if one of the roles is a "*".
                    if (role == _allRoles || 
                        context.User != null && context.User.IsInRole(role)) {
                        return true;
                    }
                }
            }

            VirtualPath virtualPath = node.VirtualPath;
            if (virtualPath == null ||
                !virtualPath.IsWithinAppRoot) {

                return false;
            }

            return System.Web.UI.Util.IsUserAllowedToPath(context, virtualPath);
        }

        protected internal virtual void RemoveNode(SiteMapNode node) {
            throw new NotImplementedException();
        }

        protected SiteMapNode ResolveSiteMapNode(HttpContext context) {
            SiteMapResolveEventHandler eventHandler = SiteMapResolve;
            if (eventHandler == null)
                return null;

            if (!context.Items.Contains(_resolutionTicket)) {
                context.Items.Add(_resolutionTicket, true);

                try {
                    Delegate[] ds = eventHandler.GetInvocationList();
                    int len = ds.Length;
                    for (int i = 0; i < len; i++) {
                        SiteMapNode ret = ((SiteMapResolveEventHandler)ds[i])(this, new SiteMapResolveEventArgs(context, this));
                        if (ret != null) {
                            return ret;
                        }
                    }
                } finally {
                    context.Items.Remove(_resolutionTicket);
                }
            }


            return null;
        }

        internal SiteMapNode ReturnNodeIfAccessible(SiteMapNode node) {
            if (node != null && node.IsAccessibleToUser(HttpContext.Current)) {
                return node;
            }

            return null;
        }
    }
}