//------------------------------------------------------------------------------
// <copyright file="ExpressionBuilder.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
 
namespace System.Web.Compilation {
    using System;
    using System.CodeDom;
    using System.Collections;
    using System.Collections.Specialized;
    using System.ComponentModel.Design;
    using System.Web.Configuration;
    using System.Reflection;
    using System.Web;
    using System.Web.Hosting;
#if !FEATURE_PAL
    using System.Web.UI.Design;
#endif // !FEATURE_PAL
    using System.Web.UI;
    using System.Web.Util;
 
 
    public abstract class ExpressionBuilder {
        private static ExpressionBuilder dataBindingExpressionBuilder;
 
        internal virtual void BuildExpression(BoundPropertyEntry bpe, ControlBuilder controlBuilder,
            CodeExpression controlReference, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject) {
 
            CodeExpression codeExpression = GetCodeExpression(bpe,
                bpe.ParsedExpressionData, new ExpressionBuilderContext(controlBuilder.VirtualPath));
 
            CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
                controlReference, bpe.Name, bpe.Type,
                codeExpression,
                linePragma);
        }
 
        internal static ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath) {
            return GetExpressionBuilder(expressionPrefix, virtualPath, null);
        }
 
        internal static ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath, IDesignerHost host) {
            // If there is no expressionPrefix, it's a v1 style databinding expression
            if (expressionPrefix.Length == 0) {
                if (dataBindingExpressionBuilder == null) {
                    dataBindingExpressionBuilder = new DataBindingExpressionBuilder();
                }
                return dataBindingExpressionBuilder;
            }
 
            CompilationSection config = null;
 
            // If we are in the designer, we need to access IWebApplication config instead
#if !FEATURE_PAL // FEATURE_PAL does not support designer-based features
            if (host != null) {
                IWebApplication webapp = (IWebApplication)host.GetService(typeof(IWebApplication));
                if (webapp != null) {
                    config = webapp.OpenWebConfiguration(true).GetSection("system.web/compilation") as CompilationSection;
                }
            }
#endif // !FEATURE_PAL
 
            // If we failed to get config from the designer, fall back on runtime config always
            if (config == null) {
                config = MTConfigUtil.GetCompilationConfig(virtualPath);
            }
 
            System.Web.Configuration.ExpressionBuilder builder = config.ExpressionBuilders[expressionPrefix];
            if (builder == null) {
                throw new HttpParseException(SR.GetString(SR.InvalidExpressionPrefix, expressionPrefix));
            }
 
            Type expressionBuilderType = null;
            if (host != null) {
                // If we are in the designer, we have to use the type resolution service
                ITypeResolutionService ts = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService));
                if (ts != null) {
                    expressionBuilderType = ts.GetType(builder.Type);
                }
            }
            if (expressionBuilderType == null) {
                expressionBuilderType = builder.TypeInternal;
            }
            Debug.Assert(expressionBuilderType != null, "expressionBuilderType should not be null");
 
            if (!typeof(ExpressionBuilder).IsAssignableFrom(expressionBuilderType)) {
                throw new HttpParseException(SR.GetString(SR.ExpressionBuilder_InvalidType, expressionBuilderType.FullName));
            }
            ExpressionBuilder expressionBuilder = (ExpressionBuilder)HttpRuntime.FastCreatePublicInstance(expressionBuilderType);
 
            return expressionBuilder;
        }
 
        //
        // Public API
        //
 
        public virtual bool SupportsEvaluate {
            get {
                return false;
            }
        }
 
        public virtual object ParseExpression(string expression, Type propertyType, ExpressionBuilderContext context) {
            return null;
        }
 
 
        public abstract CodeExpression GetCodeExpression(BoundPropertyEntry entry,
            object parsedData, ExpressionBuilderContext context);
 
        public virtual object EvaluateExpression(object target, BoundPropertyEntry entry, 
            object parsedData, ExpressionBuilderContext context) {
            return null;
        }
 
    }
}