/*

 * FCKeditor - The text editor for Internet - http://www.fckeditor.net

 * Copyright (C) 2003-2009 Frederico Caldeira Knabben

 *

 * == BEGIN LICENSE ==

 *

 * Licensed under the terms of any of the following licenses at your

 * choice:

 *

 *  - GNU General Public License Version 2 or later (the "GPL")

 *    http://www.gnu.org/licenses/gpl.html

 *

 *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")

 *    http://www.gnu.org/licenses/lgpl.html

 *

 *  - Mozilla Public License Version 1.1 or later (the "MPL")

 *    http://www.mozilla.org/MPL/MPL-1.1.html

 *

 * == END LICENSE ==

 *

 * Handles styles in a give document.

 */



var FCKStyles = FCK.Styles =

{

	_Callbacks : {},

	_ObjectStyles : {},



	ApplyStyle : function( style )

	{

		if ( typeof style == 'string' )

			style = this.GetStyles()[ style ] ;



		if ( style )

		{

			if ( style.GetType() == FCK_STYLE_OBJECT )

				style.ApplyToObject( FCKSelection.GetSelectedElement() ) ;

			else

				style.ApplyToSelection( FCK.EditorWindow ) ;



			FCK.Events.FireEvent( 'OnSelectionChange' ) ;

		}

	},



	RemoveStyle : function( style )

	{

		if ( typeof style == 'string' )

			style = this.GetStyles()[ style ] ;



		if ( style )

		{

			style.RemoveFromSelection( FCK.EditorWindow ) ;

			FCK.Events.FireEvent( 'OnSelectionChange' ) ;

		}

	},



	/**

	 * Defines a callback function to be called when the current state of a

	 * specific style changes.

	 */

	AttachStyleStateChange : function( styleName, callback, callbackOwner )

	{

		var callbacks = this._Callbacks[ styleName ] ;



		if ( !callbacks )

			callbacks = this._Callbacks[ styleName ] = [] ;



		callbacks.push( [ callback, callbackOwner ] ) ;

	},



	CheckSelectionChanges : function()

	{

		var startElement = FCKSelection.GetBoundaryParentElement( true ) ;



		if ( !startElement )

			return ;



		// Walks the start node parents path, checking all styles that are being listened.

		var path = new FCKElementPath( startElement ) ;

		var styles = this.GetStyles() ;



		for ( var styleName in styles )

		{

			var callbacks = this._Callbacks[ styleName ] ;



			if ( callbacks )

			{

				var style = styles[ styleName ] ;

				var state = style.CheckActive( path ) ;



				if ( state != ( style._LastState || null ) )

				{

					style._LastState = state ;



					for ( var i = 0 ; i < callbacks.length ; i++ )

					{

						var callback = callbacks[i][0] ;

						var callbackOwner = callbacks[i][1] ;



						callback.call( callbackOwner || window, styleName, state ) ;

					}

				}

			}

		}

	},



	CheckStyleInSelection : function( styleName )

	{

		return false ;

	},



	_GetRemoveFormatTagsRegex : function ()

	{

		var regex = new RegExp( '^(?:' + FCKConfig.RemoveFormatTags.replace( /,/g,'|' ) + ')$', 'i' ) ;



		return (this._GetRemoveFormatTagsRegex = function()

		{

			return regex ;

		})

		&& regex  ;

	},



	/**

	 * Remove all styles from the current selection.

	 * TODO:

	 *  - This is almost a duplication of FCKStyle.RemoveFromRange. We should

	 *    try to merge things.

	 */

	RemoveAll : function()

	{

		var range = new FCKDomRange( FCK.EditorWindow ) ;

		range.MoveToSelection() ;



		if ( range.CheckIsCollapsed() )

			return ;



			// Expand the range, if inside inline element boundaries.

		range.Expand( 'inline_elements' ) ;



		// Get the bookmark nodes.

		// Bookmark the range so we can re-select it after processing.

		var bookmark = range.CreateBookmark( true ) ;



		// The style will be applied within the bookmark boundaries.

		var startNode	= range.GetBookmarkNode( bookmark, true ) ;

		var endNode		= range.GetBookmarkNode( bookmark, false ) ;



		range.Release( true ) ;



		var tagsRegex = this._GetRemoveFormatTagsRegex() ;



		// We need to check the selection boundaries (bookmark spans) to break

		// the code in a way that we can properly remove partially selected nodes.

		// For example, removing a <b> style from

		//		<b>This is [some text</b> to show <b>the] problem</b>

		// ... where [ and ] represent the selection, must result:

		//		<b>This is </b>[some text to show the]<b> problem</b>

		// The strategy is simple, we just break the partial nodes before the

		// removal logic, having something that could be represented this way:

		//		<b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>



		// Let's start checking the start boundary.

		var path = new FCKElementPath( startNode ) ;

		var pathElements = path.Elements ;

		var pathElement ;



		for ( var i = 1 ; i < pathElements.length ; i++ )

		{

			pathElement = pathElements[i] ;



			if ( pathElement == path.Block || pathElement == path.BlockLimit )

				break ;



			// If this element can be removed (even partially).

			if ( tagsRegex.test( pathElement.nodeName ) )

				FCKDomTools.BreakParent( startNode, pathElement, range ) ;

		}



		// Now the end boundary.

		path = new FCKElementPath( endNode ) ;

		pathElements = path.Elements ;



		for ( var i = 1 ; i < pathElements.length ; i++ )

		{

			pathElement = pathElements[i] ;



			if ( pathElement == path.Block || pathElement == path.BlockLimit )

				break ;



			elementName = pathElement.nodeName.toLowerCase() ;



			// If this element can be removed (even partially).

			if ( tagsRegex.test( pathElement.nodeName ) )

				FCKDomTools.BreakParent( endNode, pathElement, range ) ;

		}



		// Navigate through all nodes between the bookmarks.

		var currentNode = FCKDomTools.GetNextSourceNode( startNode, true, 1 ) ;



		while ( currentNode )

		{

			// If we have reached the end of the selection, stop looping.

			if ( currentNode == endNode )

				break ;



			// Cache the next node to be processed. Do it now, because

			// currentNode may be removed.

			var nextNode = FCKDomTools.GetNextSourceNode( currentNode, false, 1 ) ;



			// Remove elements nodes that match with this style rules.

			if ( tagsRegex.test( currentNode.nodeName ) )

				FCKDomTools.RemoveNode( currentNode, true ) ;

			else

				FCKDomTools.RemoveAttributes( currentNode, FCKConfig.RemoveAttributesArray );



			currentNode = nextNode ;

		}



		range.SelectBookmark( bookmark ) ;



		FCK.Events.FireEvent( 'OnSelectionChange' ) ;

	},



	GetStyle : function( styleName )

	{

		return this.GetStyles()[ styleName ] ;

	},



	GetStyles : function()

	{

		var styles = this._GetStyles ;

		if ( !styles )

		{

			styles = this._GetStyles = FCKTools.Merge(

				this._LoadStylesCore(),

				this._LoadStylesCustom(),

				this._LoadStylesXml() ) ;

		}

		return styles ;

	},



	CheckHasObjectStyle : function( elementName )

	{

		return !!this._ObjectStyles[ elementName ] ;

	},



	_LoadStylesCore : function()

	{

		var styles = {};

		var styleDefs = FCKConfig.CoreStyles ;



		for ( var styleName in styleDefs )

		{

			// Core styles are prefixed with _FCK_.

			var style = styles[ '_FCK_' + styleName ] = new FCKStyle( styleDefs[ styleName ] ) ;

			style.IsCore = true ;

		}

		return styles ;

	},



	_LoadStylesCustom : function()

	{

		var styles = {};

		var styleDefs = FCKConfig.CustomStyles ;



		if ( styleDefs )

		{

			for ( var styleName in styleDefs )

			{

				var style = styles[ styleName ] = new FCKStyle( styleDefs[ styleName ] ) ;

				style.Name = styleName ;

			}

		}



		return styles ;

	},



	_LoadStylesXml : function()

	{

		var styles = {};



		var stylesXmlPath = FCKConfig.StylesXmlPath ;



		if ( !stylesXmlPath || stylesXmlPath.length == 0 )

			return styles ;



		// Load the XML file into a FCKXml object.

		var xml = new FCKXml() ;

		xml.LoadUrl( stylesXmlPath ) ;



		var stylesXmlObj = FCKXml.TransformToObject( xml.SelectSingleNode( 'Styles' ) ) ;



		// Get the "Style" nodes defined in the XML file.

		var styleNodes = stylesXmlObj.$Style ;



		// Check that it did contain some valid nodes

		if ( !styleNodes )

			return styles ;



		// Add each style to our "Styles" collection.

		for ( var i = 0 ; i < styleNodes.length ; i++ )

		{

			var styleNode = styleNodes[i] ;



			var element = ( styleNode.element || '' ).toLowerCase() ;



			if ( element.length == 0 )

				throw( 'The element name is required. Error loading "' + stylesXmlPath + '"' ) ;



			var styleDef = {

				Element : element,

				Attributes : {},

				Styles : {},

				Overrides : []

			} ;



			// Get the attributes defined for the style (if any).

			var attNodes = styleNode.$Attribute || [] ;



			// Add the attributes to the style definition object.

			for ( var j = 0 ; j < attNodes.length ; j++ )

			{

				styleDef.Attributes[ attNodes[j].name ] = attNodes[j].value ;

			}



			// Get the styles defined for the style (if any).

			var cssStyleNodes = styleNode.$Style || [] ;



			// Add the attributes to the style definition object.

			for ( j = 0 ; j < cssStyleNodes.length ; j++ )

			{

				styleDef.Styles[ cssStyleNodes[j].name ] = cssStyleNodes[j].value ;

			}



			// Load override definitions.

			var cssStyleOverrideNodes = styleNode.$Override ;

			if ( cssStyleOverrideNodes )

			{

				for ( j = 0 ; j < cssStyleOverrideNodes.length ; j++ )

				{

					var overrideNode = cssStyleOverrideNodes[j] ;

					var overrideDef =

					{

						Element : overrideNode.element

					} ;



					var overrideAttNode = overrideNode.$Attribute ;

					if ( overrideAttNode )

					{

						overrideDef.Attributes = {} ;

						for ( var k = 0 ; k < overrideAttNode.length ; k++ )

						{

							var overrideAttValue = overrideAttNode[k].value || null ;

							if ( overrideAttValue )

							{

								// Check if the override attribute value is a regular expression.

								var regexMatch = overrideAttValue && FCKRegexLib.RegExp.exec( overrideAttValue ) ;

								if ( regexMatch )

									overrideAttValue = new RegExp( regexMatch[1], regexMatch[2] || '' ) ;

							}

							overrideDef.Attributes[ overrideAttNode[k].name ] = overrideAttValue ;

						}

					}



					styleDef.Overrides.push( overrideDef ) ;

				}

			}



			var style = new FCKStyle( styleDef ) ;

			style.Name = styleNode.name || element ;



			if ( style.GetType() == FCK_STYLE_OBJECT )

				this._ObjectStyles[ element ] = true ;



			// Add the style to the "Styles" collection using it's name as the key.

			styles[ style.Name ] = style ;

		}



		return styles ;

	}

} ;