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

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.ComponentModel;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Globalization;
using System.IO;
using System.Web.UI;
using System.Web.Util;
using Debug=System.Web.Util.Debug;

namespace System.Web.Compilation {

    internal class PageThemeCodeDomTreeGenerator : BaseTemplateCodeDomTreeGenerator {

        private Hashtable _controlSkinTypeNameCollection = new Hashtable();
        private ArrayList _controlSkinBuilderEntryList = new ArrayList();

        private int _controlCount = 0;
        private CodeTypeReference _controlSkinDelegateType = new CodeTypeReference(typeof(ControlSkinDelegate));
        private CodeTypeReference _controlSkinType = new CodeTypeReference(typeof(ControlSkin));

        private PageThemeParser _themeParser;
        private const string _controlSkinsVarName = "__controlSkins";
        private const string _controlSkinsPropertyName = "ControlSkins";
        private const string _linkedStyleSheetsVarName = "__linkedStyleSheets";
        private const string _linkedStyleSheetsPropertyName = "LinkedStyleSheets";

        internal PageThemeCodeDomTreeGenerator(PageThemeParser parser) : base(parser) {
            _themeParser = parser;
        }

        private void AddMemberOverride(string name, Type type, CodeExpression expr) {
            CodeMemberProperty member = new CodeMemberProperty();
            member.Name = name;
            member.Attributes = MemberAttributes.Override | MemberAttributes.Family;
            member.Type = new CodeTypeReference(type.FullName);
            CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(expr);
            member.GetStatements.Add(returnStmt);
            _sourceDataClass.Members.Add(member);
        }

        private void BuildControlSkins(CodeStatementCollection statements) {
            foreach (ControlSkinBuilderEntry entry in _controlSkinBuilderEntryList) {
                string skinID = entry.SkinID;
                ControlBuilder builder = entry.Builder;
                statements.Add(BuildControlSkinAssignmentStatement(builder, skinID));
            }
        }

        private CodeStatement BuildControlSkinAssignmentStatement(
            ControlBuilder builder, string skinID) {

            Type controlType = builder.ControlType;

            string keyVarName = GetMethodNameForBuilder(buildMethodPrefix, builder) + "_skinKey";

            // e.g.
            // private static object __BuildControl__control3_skinKey = PageTheme.CreateSkinKey(typeof({controlType}), {skinID});
            CodeMemberField field = new CodeMemberField(typeof(object), keyVarName);
            field.Attributes = MemberAttributes.Static | MemberAttributes.Private;
            CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression();
            cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(PageTheme)), "CreateSkinKey");
            cmie.Parameters.Add(new CodeTypeOfExpression(controlType));
            cmie.Parameters.Add(new CodePrimitiveExpression(skinID));
            field.InitExpression = cmie;
            _sourceDataClass.Members.Add(field);

            // e.g. this.__namedControlSkins[keyVarName] =
            //          new System.Web.UI.ControlSkin(typeof(System.Web.UI.WebControls.Label),
            //          new System.Web.UI.ControlSkinDelegate(this.__BuildControl__control3));
            CodeFieldReferenceExpression varExpr = new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(),
                _controlSkinsVarName);

            CodeIndexerExpression indexerExpr = new CodeIndexerExpression(
                varExpr,
                new CodeExpression[] {
                    new CodeVariableReferenceExpression(keyVarName)
                }
            );

            CodeDelegateCreateExpression del = new CodeDelegateCreateExpression(
                                                            _controlSkinDelegateType,
                                                            new CodeThisReferenceExpression(),
                                                            GetMethodNameForBuilder(buildMethodPrefix, builder));
            CodeObjectCreateExpression valueExpr = new CodeObjectCreateExpression(_controlSkinType);
            valueExpr.Parameters.Add(new CodeTypeOfExpression(controlType));
            valueExpr.Parameters.Add(del);

            return new CodeAssignStatement(indexerExpr, valueExpr);
        }

        private void BuildControlSkinMember() {
            // e.g.
            // private System.Collections.Specialized.HybridDictionary __cssFileList =
            //     new System.Collections.Specialized.HybridDictionary(2);
            int initialSize = _controlSkinBuilderEntryList.Count;
            CodeMemberField field = new CodeMemberField(typeof(HybridDictionary).FullName, _controlSkinsVarName);
            CodeObjectCreateExpression expr = new CodeObjectCreateExpression(typeof(HybridDictionary));
            expr.Parameters.Add(new CodePrimitiveExpression(initialSize));
            field.InitExpression = expr;
            _sourceDataClass.Members.Add(field);
        }

        private void BuildControlSkinProperty() {
            // e.g.
            //  protected override System.Collections.IDictionary ControlSkins {
            //       get { return this.__controlSkins; }
            //  }
            CodeFieldReferenceExpression accessExpr = new CodeFieldReferenceExpression(
                                                            new CodeThisReferenceExpression(),
                                                            _controlSkinsVarName);

            AddMemberOverride(_controlSkinsPropertyName, typeof(IDictionary), accessExpr);
        }

        private void BuildLinkedStyleSheetMember() {

            // e.g.
            // private System.String[] __linkedStyleSheets = new String[] {
            //     "linkedStyleSheet1 vdirs",
            //     "linkedStyleSheet2 vdirs",
            // }
            CodeMemberField field = new CodeMemberField(typeof(String[]), _linkedStyleSheetsVarName);

            if (_themeParser.CssFileList != null && _themeParser.CssFileList.Count > 0) {
                CodeExpression[] cssFiles = new CodeExpression[_themeParser.CssFileList.Count];
                int i = 0;
                foreach(String cssFile in _themeParser.CssFileList) {
                    cssFiles[i++] = new CodePrimitiveExpression(cssFile);
                }
                
                CodeArrayCreateExpression initExpr = new CodeArrayCreateExpression(typeof(String), cssFiles);
                field.InitExpression = initExpr;
            }
            else {
                field.InitExpression = new CodePrimitiveExpression(null);
            }
            _sourceDataClass.Members.Add(field);
        }

        private void BuildLinkedStyleSheetProperty() {
            // e.g.
            //  protected override String[] LinkedStyleSheets {
            //       get { return this.__linkedStyleSheets; }
            //  }
            CodeFieldReferenceExpression accessExpr = new CodeFieldReferenceExpression(
                                                            new CodeThisReferenceExpression(),
                                                            _linkedStyleSheetsVarName);

            AddMemberOverride(_linkedStyleSheetsPropertyName, typeof(String[]), accessExpr);
        }

        protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements) {
            base.BuildInitStatements(trueStatements, topLevelStatements);
            BuildControlSkins(topLevelStatements);
        }

        protected override void BuildMiscClassMembers() {
            base.BuildMiscClassMembers();

            AddMemberOverride(templateSourceDirectoryName, typeof(String),
                new CodePrimitiveExpression(_themeParser.VirtualDirPath.VirtualPathString));

            BuildSourceDataTreeFromBuilder(_themeParser.RootBuilder,
                false /*fInTemplate*/, false /*topLevelControlInTemplate*/, null /*pse*/);

            BuildControlSkinMember();
            BuildControlSkinProperty();
            BuildLinkedStyleSheetMember();
            BuildLinkedStyleSheetProperty();
        }

        protected override void BuildSourceDataTreeFromBuilder(ControlBuilder builder,
                                                bool fInTemplate, bool topLevelControlInTemplate,
                                                PropertyEntry pse) {

            // Don't do anything for code blocks
            if (builder is CodeBlockBuilder)
                return;

            // Is the current builder for a template?
            bool fTemplate = (builder is TemplateBuilder);

            // Is the current builder the root builder?
            bool fRootBuilder = (builder == _themeParser.RootBuilder);

            // Is this a control theme?
            bool fControlSkin = !fInTemplate && !fTemplate && topLevelControlInTemplate;

            // Ignore the ID attribute, always auto generate ID.
            _controlCount++;
            builder.ID = "__control" + _controlCount.ToString(NumberFormatInfo.InvariantInfo);
            builder.IsGeneratedID = true;

            // Check for the SkinID property.
            if (fControlSkin && !(builder is DataBoundLiteralControlBuilder)) {

                Type ctrlType = builder.ControlType;
                Debug.Assert(typeof(Control).IsAssignableFrom(ctrlType));
                Debug.Assert(ThemeableAttribute.IsTypeThemeable(ctrlType));

                string skinID = builder.SkinID;
                object skinKey = PageTheme.CreateSkinKey(builder.ControlType, skinID);

                if (_controlSkinTypeNameCollection.Contains(skinKey)) {
                    if (String.IsNullOrEmpty(skinID)) {
                        throw new HttpParseException(SR.GetString(SR.Page_theme_default_theme_already_defined,
                            builder.ControlType.FullName), null, builder.VirtualPath, null, builder.Line);
                    }
                    else {
                        throw new HttpParseException(SR.GetString(SR.Page_theme_skinID_already_defined, skinID),
                            null, builder.VirtualPath, null, builder.Line);
                    }
                }

                _controlSkinTypeNameCollection.Add(skinKey, true);
                _controlSkinBuilderEntryList.Add(new ControlSkinBuilderEntry(builder, skinID));
            }

            // Process the children
            // only root builders and template builders are processed.
            if (builder.SubBuilders != null) {
                foreach (object child in builder.SubBuilders) {
                    if (child is ControlBuilder) {
                        bool isTopLevelCtrlInTemplate = fTemplate && typeof(Control).IsAssignableFrom(((ControlBuilder)child).ControlType);
                        BuildSourceDataTreeFromBuilder((ControlBuilder)child, fInTemplate, isTopLevelCtrlInTemplate, null);
                    }
                }
            }

            foreach (TemplatePropertyEntry entry in builder.TemplatePropertyEntries) {
                BuildSourceDataTreeFromBuilder(((TemplatePropertyEntry)entry).Builder, true, false /*topLevelControlInTemplate*/, entry);
            }

            foreach (ComplexPropertyEntry entry in builder.ComplexPropertyEntries) {
                if (!(entry.Builder is StringPropertyBuilder)) {
                    BuildSourceDataTreeFromBuilder(((ComplexPropertyEntry)entry).Builder, fInTemplate, false /*topLevelControlInTemplate*/, entry);
                }
            }

            // Build a Build method for the control
            // fControlSkin indicates whether the method is a theme build method.
            if (!fRootBuilder) {
                BuildBuildMethod(builder, fTemplate, fInTemplate, topLevelControlInTemplate, pse,
                    fControlSkin);
            }

            // Build a Render method for the control, unless it has no code
            if (!fControlSkin && builder.HasAspCode) {
                BuildRenderMethod(builder, fTemplate);
            }

            // Build a method to extract values from the template
            BuildExtractMethod(builder);

            // Build a property binding method for the control
            BuildPropertyBindingMethod(builder, fControlSkin);
        }

        internal override CodeExpression BuildStringPropertyExpression(PropertyEntry pse) {
            // Make the UrlProperty based on virtualDirPath for control themes.
            if (pse.PropertyInfo != null) {
                UrlPropertyAttribute urlAttrib = Attribute.GetCustomAttribute(pse.PropertyInfo, typeof(UrlPropertyAttribute)) as UrlPropertyAttribute;

                if (urlAttrib != null) {
                    if (pse is SimplePropertyEntry) {
                        SimplePropertyEntry spse = (SimplePropertyEntry)pse;

                        string strValue = (string)spse.Value;
                        if (UrlPath.IsRelativeUrl(strValue) && !UrlPath.IsAppRelativePath(strValue)) {
                            spse.Value = UrlPath.MakeVirtualPathAppRelative(UrlPath.Combine(_themeParser.VirtualDirPath.VirtualPathString, strValue));
                        }
                    }
                    else {
                        Debug.Assert(pse is ComplexPropertyEntry);
                        ComplexPropertyEntry cpe = (ComplexPropertyEntry)pse;
                        StringPropertyBuilder builder = (StringPropertyBuilder)cpe.Builder;

                        string strValue = (string)builder.BuildObject();
                        if (UrlPath.IsRelativeUrl(strValue) && !UrlPath.IsAppRelativePath(strValue)) {
                            cpe.Builder = new StringPropertyBuilder(UrlPath.MakeVirtualPathAppRelative(UrlPath.Combine(_themeParser.VirtualDirPath.VirtualPathString, strValue)));
                        }
                    }
                }
            }

            return base.BuildStringPropertyExpression(pse);
        }

        protected override CodeAssignStatement BuildTemplatePropertyStatement(CodeExpression ctrlRefExpr) {

            // e.g. __ctrl.AppRelativeTemplateSourceDirectory = this.AppRelativeTemplateSourceDirectory;
            CodeAssignStatement assign = new CodeAssignStatement();
            assign.Left = new CodePropertyReferenceExpression(ctrlRefExpr, templateSourceDirectoryName);
            assign.Right = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), templateSourceDirectoryName);
            return assign;
        }

        protected override string GetGeneratedClassName() {
            string className = _themeParser.VirtualDirPath.FileName;
            className = System.Web.UI.Util.MakeValidTypeNameFromString(className);

            return className;
        }

        protected override bool UseResourceLiteralString(string s) {
            // never use resource literal string, page theme does not support the required methods.
            return false;
        }

        // Don't build the Profile property in Theme classes
        protected override bool NeedProfileProperty { get { return false; } }

        private class ControlSkinBuilderEntry {
            private ControlBuilder _builder;
            private string _id;

            public ControlSkinBuilderEntry (ControlBuilder builder, string skinID) {
                _builder = builder;
                _id = skinID;
            }

            public ControlBuilder Builder {
                get { return _builder; }
            }

            public String SkinID {
                get { return _id == null? String.Empty : _id; }
            }
        }
    }
}