static NVelocityHelper()
 {
     _velocity = new VelocityEngine();
     var props = new ExtendedProperties();
     props.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, ConfigurationManager.AppSettings["TemplateFolder"]);
     _velocity.Init(props);
 }

        public string RenderTemplate(string masterPage, string templateName, IDictionary<string, object> data)
        {
            if (string.IsNullOrEmpty(templateName))
            {
                throw new ArgumentException("The \"templateName\" parameter must be specified", "templateName");
            }

            var name = !string.IsNullOrEmpty(masterPage)
                 ? masterPage : templateName;

            var engine = new VelocityEngine();
            var props = new ExtendedProperties();
            props.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, _templatesPath);
            engine.Init(props);
            var template = engine.GetTemplate(name);
            template.Encoding = Encoding.UTF8.BodyName;
            var context = new VelocityContext();

            var templateData = data ?? new Dictionary<string, object>();
            foreach (var key in templateData.Keys)
            {
                context.Put(key, templateData[key]);
            }

            if (!string.IsNullOrEmpty(masterPage))
            {
                context.Put("childContent", templateName);
            }

            using (var writer = new StringWriter())
            {
                engine.MergeTemplate(name, context, writer);
                return writer.GetStringBuilder().ToString();
            }
        }

        public static string Format(HttpContext context, string pattern, VelocityContext velocitycontext)
        {
                using (var writer = new StringWriter())
                {
                    try
                    {
                        if (!_isInitialized)
                        {
                            var props = new ExtendedProperties();
                            props.AddProperty("file.resource.loader.path",
                                              new ArrayList(new[]
                                                                {
                                                                    ".",
                                                                    Path.Combine(
                                                                        context.Server.MapPath(feed.HandlerBasePath),
                                                                        "Patterns")
                                                                }));
                            Velocity.Init(props);
                            _isInitialized = true;
                        }
                        //Load patterns
                        var template = Patterns.Get(pattern, () => LoadTemplate(pattern));

                        template.Merge(velocitycontext, writer);
                        return writer.GetStringBuilder().ToString();

                    }
                    catch (Exception)
                    {
                        //Format failed some way
                        return writer.GetStringBuilder().ToString();
                    }
                }
        }

		public void Initialize()
		{
            ActiveRecordStarter.Initialize( new XmlConfigurationSource("activeRecord.xml"),
              typeof(Acl) ,
              typeof(Category) ,
              typeof(Chat) ,
              typeof(ChatMessage) ,
              typeof(ConfigCombo) ,
              typeof(ConfigModel) ,
              typeof(Container) ,
              typeof(Content) ,
              typeof(DataModel) ,
              typeof(Field) ,
              typeof(FieldTemplate) ,
              typeof(CastlePortal.File) ,
              typeof(Forum) ,
              typeof(ForumFolder) ,
              typeof(ForumMessage) ,
              typeof(Group) ,
              typeof(Menu) ,
              typeof(Role) ,
              typeof(CastlePortal.Template) ,
              typeof(CastlePortal.Type) ,
              typeof(Language),
              typeof(MenuTranslation),
              typeof(TypeTranslation),
              typeof(User)
           );
           
           velocity = new VelocityEngine();
           ExtendedProperties props = new ExtendedProperties();
           velocity.Init(props);
		}

		private void SetLoaderPath(ExtendedProperties properties)
		{
			string loaderPath = "";
			// TODO: Solve multiple loader path problem in NVelocity
			if (Template.FileName == "")
			{
				loaderPath = BaseFolder;
			}
			else
			{
				loaderPath = Path.GetDirectoryName(Template.GetFullPath());
				if (loaderPath.IndexOf(BaseFolder) < 0 && loaderPath != BaseFolder)
				{
					loaderPath = BaseFolder + "," + loaderPath;
				}
				else if (loaderPath != BaseFolder)
				{
					loaderPath += "," + BaseFolder;
				}
			}
			// HACK: Setting loader path to base folder until loader problem is solved
			//loaderPath = BaseFolder;
			//System.Diagnostics.Debug.WriteLine("NVeleocity:loaderPath=" + loaderPath);
			if (properties.Contains("file.resource.loader.path"))
			{
				properties["file.resource.loader.path"] = loaderPath;
			}
			else
			{
				properties.AddProperty("file.resource.loader.path", loaderPath);
			}
		}

		protected void InitialiseNVelocity(string templatePath) {

			ExtendedProperties props = new ExtendedProperties();
			props.SetProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, TemplatePath);
			
			Velocity.Init(props);
		}

        public static void CreateCode(string filepath, string outputpath, VelocityContext context)
        {
            StreamWriter writer=null;
            try
            {
                VelocityEngine engine = null;//new VelocityEngine();
                ExtendedProperties extendedProperties = new ExtendedProperties();
                //extendedProperties.SetProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, filepath.Substring(0, filepath.LastIndexOf("\\")));

                engine.Init(extendedProperties);
                //Template template = engine.GetTemplate(filepath.Substring(filepath.LastIndexOf("\\")+1));
                //FileStream fos = new FileStream(outputpath + "\\1.vm", FileMode.Create);
                //writer = new StreamWriter(fos);
                //template.Merge(context, writer);
                //writer.Flush();
                //writer.Close();
                StringWriter output=new StringWriter();
                engine.Evaluate(context, output, "", filepath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (writer != null)
                {
                    writer.Close();
                }
            }
        }

        public void Test()
        {
            var velocityEngine = new VelocityEngine();

            ExtendedProperties extendedProperties = new ExtendedProperties();
            extendedProperties.SetProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, TemplateTest.FILE_RESOURCE_LOADER_PATH);

            velocityEngine.Init(extendedProperties);

            VelocityContext context = new VelocityContext();

            context.Put("yada", "line");

            Template template = velocityEngine.GetTemplate(
                GetFileName(null, "nv37", TemplateTest.TMPL_FILE_EXT));

            StringWriter writer = new StringWriter();

            #pragma warning disable 612,618
            velocityEngine.MergeTemplate("nv37.vm", context, writer);
            #pragma warning restore 612,618

            //template.Merge(context, writer);

            Console.WriteLine(writer);
        }

 private VelocityEngine CreateVelocityEngine()
 {
     var velocity = new VelocityEngine();
     var props = new ExtendedProperties();
     props.SetProperty("file.resource.loader.path", _templateDirectory);
     velocity.Init(props);
     return velocity;
 }

 private static ExtendedProperties GetBasicProperties()
 {
     ExtendedProperties properties = new ExtendedProperties();
     properties.AddProperty("resource.loader", "assembly");
     properties.AddProperty("assembly.resource.loader.class",
         "NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader, NVelocity");
     return properties;
 }

        public NVelocityTemplateRepository(string templateDirectory)
        {
            engine = new VelocityEngine();
            ExtendedProperties props = new ExtendedProperties();
            props.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, templateDirectory);

            engine.Init(props);
        }

 /// <inheritdoc />
 public VelocityEngine CreateVelocityEngine()
 {
     var properties = new ExtendedProperties();
     SetupVelocityEngine(properties);
     var engine = new VelocityEngine(properties);
     engine.Init();
     return engine;
 }

 public TemplateHelper(string templatePath)
 {
     velocity = new VelocityEngine();
     ExtendedProperties props = new ExtendedProperties();
     props.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, templatePath);
     props.AddProperty(RuntimeConstants.INPUT_ENCODING, "utf-8");
     velocity.Init(props);
     context = new VelocityContext();
 }

        public virtual bool Configure()
        {
            _engine = new VelocityEngine();
            var props = new ExtendedProperties();
            props.AddProperty("file.resource.loader.path", TemplatePath);
            _engine.Init(props);

            return true;
        }

 private VelocityEngine GetInitialisedEngine()
 {
     VelocityEngine engine = new VelocityEngine();
     ExtendedProperties properties = new ExtendedProperties();
     properties.SetProperty(RuntimeConstants.RESOURCE_LOADER, "file");
     properties.SetProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, agencyService.CurrentAgency.TemplateDirectory);
     engine.Init(properties);
     return engine;
 }

		/// <summary> 
		/// Initialize the template loader with a
		/// a resources class.
		/// </summary>
		public override void Init(ExtendedProperties configuration)
		{
			assemblyNames = configuration.GetVector("assembly");
			prefixes = configuration.GetVector("prefix");
			if (assemblyNames.Count != prefixes.Count)
			{
				throw new ResourceNotFoundException("Need to specify prefixes!");
			}
		}

        public void  Apply(IEnumerable<ChangeScript> changeScripts)
        {
            string filename = string.Format(CultureInfo.InvariantCulture, "{0}_{1}.vm", this.syntax, this.GetTemplateQualifier());

            var model = new Hashtable();
            
            model.Add("scripts", changeScripts);
            model.Add("changeLogTableName", this.changeLogTableName);
            model.Add("delimiter", this.delimiter);
            model.Add("separator", this.delimiterType is RowDelimiter ? Environment.NewLine : string.Empty);

            try
            {
                ExtendedProperties props = new ExtendedProperties();

                var assemblyName = typeof(TemplateBasedApplier).Assembly.GetName().Name;

                ReplaceManagersWithDbDeployVersions(props, assemblyName);

                if (this.templateDirectory == null)
                {
                    props.AddProperty("resource.loader", "assembly");

                    // The ";" will be replaced by "," in the resource loader factory.
                    // This is because if we add a property with a comma in the value, it will add *two* values to the property.
                    props.AddProperty(
                        "assembly.resource.loader.class",
                        typeof(DbDeployAssemblyResourceLoader).FullName + "; " + assemblyName);

                    props.AddProperty("assembly.resource.loader.assembly", assemblyName);
                    filename = "Net.Sf.Dbdeploy.Resources." + filename;
                }
                else
                {
                    props.SetProperty("file.resource.loader.path", this.templateDirectory.FullName);
                }

                var templateEngine = new VelocityEngine(props);

                var context = new VelocityContext(model);

                Template template = templateEngine.GetTemplate(filename);

                template.Merge(context, this.writer);
            }
            catch (ResourceNotFoundException ex)
            {
                string locationMessage = templateDirectory == null 
                    ? string.Empty 
                    : (" at " + templateDirectory.FullName);

                throw new UsageException(
                    "Could not find template named " + filename + locationMessage + Environment.NewLine + "Check that you have got the name of the database syntax correct.",
                    ex);
            }
        }

        public override void Configure(DirectoryInfo workingDirectory, NameValueCollection props)
        {
            try
            {
                File.Delete("nvelocity.log");
            }
            catch (IOException)
            {
                // TODO: This is evil! need to investigate further. Cannot get
                // exclusive lock on the log file with this assembly now a
                // library (as opposed to an exe). However not convinced that
                // the line isn't a hangover from java conversion. Need to
                // investigate further.
                ;
            }
            base.Configure(workingDirectory, props);
            ExtendedProperties p = new ExtendedProperties();
            string templateName = props["template"];
            string templateSrc;
            if (templateName == null)
            {
                log.Info("No template file was specified, using default");
                p.SetProperty("resource.loader", "class");
                p.SetProperty("class.resource.loader.class", "NHibernate.Tool.hbm2net.StringResourceLoader;NHibernate.Tool.hbm2net");
                templateSrc =
                    new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("NHibernate.Tool.hbm2net.convert.vm")).
                        ReadToEnd();
            }
            else
            {
                // NH-242 raised issue of where NVelocity looks when supplied with a unpathed file name. Hence
                // will take responsiblity of explicitly instructing NVelocity where to look.
                if (!Path.IsPathRooted(templateName))
                {
                    templateName = Path.Combine(this.WorkingDirectory.FullName, templateName);
                }
                if (!File.Exists(templateName))
                {
                    string msg =
                        string.Format("Cannot find template file using absolute path or relative to '{0}'.",
                                      this.WorkingDirectory.FullName);
                    throw new IOException(msg);
                }

                p.SetProperty("resource.loader", "class");
                p.SetProperty("class.resource.loader.class", "NHibernate.Tool.hbm2net.StringResourceLoader;NHibernate.Tool.hbm2net");
                using (StreamReader sr = new StreamReader(File.OpenRead(templateName)))
                {
                    templateSrc = sr.ReadToEnd();
                    sr.Close();
                }
            }
            ve = new VelocityEngine();
            ve.Init(p);
            template = ve.GetTemplate(templateSrc);
        }

	/// <summary>
	/// overridden LoadConfiguration that will create a properties file on the fly
	/// </summary>
	/// <returns></returns>
	protected override ExtendedProperties LoadConfiguration() {
	    ExtendedProperties p = new ExtendedProperties();

	    // override the loader path and log file locations based on where the physical application path is
	    p.SetProperty(NVelocity.Runtime.RuntimeConstants_Fields.FILE_RESOURCE_LOADER_PATH, context.Request.PhysicalApplicationPath);
	    p.SetProperty(NVelocity.Runtime.RuntimeConstants_Fields.RUNTIME_LOG,
			  context.Request.PhysicalApplicationPath + p.GetString(NVelocity.Runtime.RuntimeConstants_Fields.RUNTIME_LOG, "nvelocity.log"));

	    return p;
	}

 static NVelocity()
 {
     filePath = Utils.GetMapPath(BaseConfigs.GetForumPath);
     engine = new VelocityEngine();
     props = new ExtendedProperties();
     props.AddProperty(RuntimeConstants.INPUT_ENCODING, "utf-8");
     props.AddProperty(RuntimeConstants.OUTPUT_ENCODING, "utf-8");
     props.AddProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, filePath);
     engine.Init(props);
 }