// Copyright May 16, 2006 The Apache Software Foundation
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  package net.sf.tacos.components.dojo;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import net.sf.tacos.binding.ICallbackFunction;
  import net.sf.tacos.util.JSONMarkupWriter;
  
  import org.apache.tapestry.IActionListener;
  import org.apache.tapestry.IBinding;
  import org.apache.tapestry.IDirect;
  import org.apache.tapestry.IMarkupWriter;
  import org.apache.tapestry.IRequestCycle;
  import org.apache.tapestry.IScript;
  import org.apache.tapestry.Tapestry;
  import org.apache.tapestry.TapestryUtils;
  import org.apache.tapestry.dojo.IWidget;
  import org.apache.tapestry.engine.DirectServiceParameter;
  import org.apache.tapestry.engine.IEngineService;
  import org.apache.tapestry.engine.ILink;
  import org.apache.tapestry.event.BrowserEvent;
  import org.apache.tapestry.json.JSONObject;
  import org.apache.tapestry.link.DirectLink;
  import org.apache.tapestry.listener.ListenerInvoker;
  
  /**
   * Implementation of any dojo widget as a tapestry component.
   * The formal parameter <code>dojoType</code> is used to determine which dojo widget to create. 
   * Informal parameters are used as javascript properties to create widget with.
   * Please have a look into the <a href="http://dojotoolkit.org/api">http://dojotoolkit.org/api</a>
   * for further information about the widget properties. A simple example is the dojo Clock widget: 
   *<pre>
   *&lt;div jwcid="@dojo:Widget" dojoType="Clock" timeZoneOffset="5" labelColor="#fff"/&gt;
   *</pre>
   * <p>
   * The formal parameter <code>isContainer</code> allows a widget to have children.
   * All the widgets within the body of a container are added as childs. For example dojo tabs:
   * </p>
   * <pre>
   *&lt;div jwcid="@dojo:Widget" dojoType="TabContainer" isContainer="true"&gt;
   *	&lt;div jwcid="@dojo:Widget" dojoType="ContentPane" label="Athens"&gt;Athens&lt;/div&gt;
   *	&lt;div jwcid="@dojo:Widget" dojoType="ContentPane" label="Moscow"&gt;Moscow&lt;/div&gt;
   *&lt;/div&gt;
   *</pre>
   * <p>
   * DojoWidget allows you to connect any client side event to a listener method.
   * Please see the dojo api for further information about the events fired by the particular widget.
   * To connect a client side even just use the informal parameter with the corresponding name.
   * For example, specifying a component definition such as:
   * </p>
   * <pre>
   * &lt;div jwcid="@dojo:Widget" dojoType="..." onClick="listener:onClick" onMouseDown="listener:onMouseDown"/&gt;
   * </pre>
   * <p>
   * It's possible to specify a list of events for which to generate non async requests specifying the dojo events
   * list in the noAsync parameter as a comma separated list. This is particularly useful
   * with menu/button widget that most of the times need normal requests to be generated.
   * <pre>
   * &lt;div jwcid="@dojo:Widget" dojoType="MenuItem2" onClick="listener:onMenuClick" noAsync="onClick"/&gt;
   * </pre>
   * </p>
   * Furthermore it is poossible to connect a client side event to a javascript function.
   * For this purpose use the prefix <code>callback</code>. For example:
   * </p>
   * <pre>
   * &lt;div jwcid="@dojo:Widget" dojoType="SliderHorizontal" onValueChanged="callback:sliderCallback"/&gt;
   * </pre>
   *  <p>Whereby <code>sliderCallback</code> is a javascript function:</p>
   * <pre>
   *  function sliderCallback(value) {
   *  	alert(value);
   *  }
   * </pre>
   * @since 4.1.0
   */
  public abstract class DojoWidget extends GenericWidget implements IDojoContainer, IDirect{
  
  	public static final String CONTAINER_ATTRIBUTE = DojoWidget.class.getName();
          
      /**
       * If the current component is a container.<br/>
       * If the user has defined a value for 'isContainer', then that is used.
       *
      * Otherwise, several rules are used to determine if the component is
      * a valid container. The rules are:<ul>
      * <li>the dojoType parameter ends with 'Container'.</li>
      * </ul>
      *
      */
     public boolean getContainerState() {
         if (isParameterBound("isContainer")) {
             return getIsContainer();
         } else {
             String type = getDojoType();
             return (type.endsWith("Container") || type.equals("ContentPane"));
         }
     }
     
     /**
      * {@inheritDoc}
      */
     public void renderWidget(IMarkupWriter writer, IRequestCycle cycle){
         boolean isContainer = getContainerState();
         IDojoContainer previousContainer = (IDojoContainer) cycle.getAttribute(CONTAINER_ATTRIBUTE);
         boolean rewinding = cycle.isRewinding();
         
         if (!rewinding) {
             writer.begin(getTemplateTagName());
             renderIdAttribute(writer, cycle);
             String style = getStyle();
             if (style!=null)
                 writer.attribute("style", style);
             
             if(isContainer){
                 cycle.setAttribute(CONTAINER_ATTRIBUTE, this);
             }
         }
         
         renderBody(writer, cycle);
         
         if (!rewinding) {
         	writer.end();
 
             if (previousContainer!=null)
                 previousContainer.addChild(this);            
 
             JSONMarkupWriter jsonWriter = new JSONMarkupWriter();
             renderInformalParameters(jsonWriter, cycle);
             JSONObject json = jsonWriter.getAttributes();
             
             Map asynclisteners = getAsyncListenerBindings();
             Map listeners = getListenerBindings();
             Map callbacks = getCallbackBindings();
             removeListenersFromInputSymbols(json, asynclisteners);
             removeListenersFromInputSymbols(json, listeners);
             removeListenersFromInputSymbols(json, callbacks);
 
             Map parms = new HashMap();
             String url = getLink().getURL();
             parms.put("component", this);
             parms.put("type", getDojoType());
             parms.put("url", url);
             parms.put("props", json.toString());
             parms.put("asynclisteners", asynclisteners);
             parms.put("listeners", listeners);
             parms.put("callbacks", callbacks);
             getScript().execute(this, cycle, TapestryUtils.getPageRenderSupport(cycle, this), parms);
 
             cycle.setAttribute(CONTAINER_ATTRIBUTE, previousContainer);
         }
     }
     
     
     /**
      * {@inheritDoc}
      */
 	public void addChild(IWidget widget) {
             // need to store the clientIds here instead of the widget instances,
             // cause that's what's changing
 		getChildren().add(widget.getClientId());
 	}
 	
 	/**
 	 * The informal parameters of the component are used as arguments for <code>dojo.widget.Widget</code>.
 	 * The method {@link this{@link #renderInformalParameters(IMarkupWriter, IRequestCycle)}}
 	 * is used to pass through these parameters to the dojo widget. Some of the parameters does not
 	 * represent dojo arguments and should not be passed through.
 	 * This method can be used to remove specified bindings from the Map of input symbols.
 	 * @param json json object to remove bindings from 
 	 * @param bindings bindings to remove
 	 */
 	private void removeListenersFromInputSymbols(JSONObject json, Map bindings){
 		Iterator i = bindings.keySet().iterator();
 		while(i.hasNext()){
 			json.remove((String)i.next());
 		}
 	}
 	
 	/**
 	 * Returns a {@link Map} of the {@link org.apache.tapestry.IBinding bindings} implementing
 	 * the {@link org.apache.tapestry.IActionListener} interface.
 	 */
 	private Map getAllListenerBindings(){
 		return getBindingsByClass(getBindingNames(), IActionListener.class);
 	}
 
 	/**
 	 * Returns a {@link Map} of the {@link org.apache.tapestry.IBinding bindings} implementing
 	 * the {@link org.apache.tapestry.IActionListener} interface for which to
 	 * generate non async requests.
 	 */
 	public Map getListenerBindings(){
 		Map listeners = getBindingsByClass(getBindingNames(), IActionListener.class);
 		Map result = new HashMap();
 		String[] noAsync = constructNoAsync();
 		if (noAsync != null) {
 			for (int i = 0; i < noAsync.length; i++) {
 				if (listeners.get(noAsync[i]) != null) {
 					result.put(noAsync[i], listeners.get(noAsync[i]));
 				}
 			}		
 		}
 		return result;
 	}
 	/**
 	 * Returns a {@link Map} of the {@link org.apache.tapestry.IBinding bindings} implementing
 	 * the {@link org.apache.tapestry.IActionListener} interface for which
 	 * to generate async requests.
 	 */
 	public Map getAsyncListenerBindings(){
 		Map listeners = getBindingsByClass(getBindingNames(), IActionListener.class);
 		String[] noAsync = constructNoAsync();
 		if (noAsync != null) {
 			for (int i = 0; i < noAsync.length; i++) {
 				listeners.remove(noAsync[i]);
 			}
 		}
 		return listeners;
 	}
 	
 	/**
 	 * Returns an array containing the names of the events for which not to generate
 	 * async requests
 	 */
 	private String[] constructNoAsync() {
 		String noAsync = getNoAsync();
 		if (noAsync != null) {
 			if (noAsync.indexOf(",") != -1) {
 				return noAsync.split(",");
 			} else {
 				String[] result = {noAsync};
 				return result;
 			}
 		}
 		return null;
 	}
 	
 	/**
 	 * Returns a {@link Map} of the {@link org.apache.tapestry.IBinding bindings} implementing
 	 * the {@link net.sf.tacos.binding.ICallbackFunction} interface.
 	 */
 	public Map getCallbackBindings(){
 		return getBindingsByClass(getBindingNames(), ICallbackFunction.class);
 	}
 	
 	/**
 	 * Filters the {@link Map} of the {@link org.apache.tapestry.IBinding bindings} of the component 
 	 * and returns a {@link Map} of {@link org.apache.tapestry.IBinding bindings} the specified Class parameter
 	 * is assignable from.
 	 * 
 	 * @param names names of the bindings 
 	 * @param clazz class to determine if it is assignable from the bindings
 	 */
 	protected Map getBindingsByClass(Collection names, Class clazz){
 		Map result = new HashMap();
 		Iterator i = names.iterator();
 		while(i.hasNext()){
 			String name = (String)i.next();
 			IBinding binding = getBinding(name);
 			if(clazz.isAssignableFrom(binding.getClass())){
 				result.put(name, binding);
 			}
 		}
 		return result;
 	}
 	
 	/**Returns a link*/
 	private ILink getLink(){
 		Object[] parameters = DirectLink.constructServiceParameters(getParameters());
 		DirectServiceParameter dsp = new DirectServiceParameter(this, parameters);
 		return getEngine().getLink(isStateful(), dsp);
 	}
 	
 	/** Returns the url to use for a non async event  */
 	public String getNoAsyncEventUrl(String eventName){
 		Object[] parameters = DirectLink.constructServiceParameters(getParameters());
 		DirectServiceParameter dsp = new DirectServiceParameter(this, parameters);
 		return getEngine().getLink(isStateful(), dsp).getURL() + "&" 
 			+ BrowserEvent.NAME + "=" + eventName;
 	}
 		
     /**
      * Invoked by the direct service to trigger the application-specific action by notifying the
      * {@link IActionListener listener}.
      */
 	public void trigger(IRequestCycle cycle) {
         String event = cycle.getParameter(BrowserEvent.NAME);
         IActionListener listener = (IActionListener)getAllListenerBindings().get(event);
         if (listener == null)
             throw Tapestry.createRequiredParameterException(this, event);
         getListenerInvoker().invokeListener(listener, this, cycle);
 		
 	}
 
     /** Injected script. */
     public abstract IScript getScript();
     
     /** Injected engine service . */
     public abstract IEngineService getEngine();
     
     /** Injected listener invoker. */
     public abstract ListenerInvoker getListenerInvoker();
     
     /** Returns the style. */
     public abstract String getStyle();
     
     /** Returns the type of the dojo widget */
     public abstract String getDojoType();
     
     /**Returns listener parameters*/
     public abstract Object getParameters();
     
     /** Returns widget events for which to generate no async requests */
     public abstract String getNoAsync();
     
     /**
      * Returns a list of children widgetIds.
      * The list is always empty if {@link #getIsContainer()} returns <code>false</code>.
      */
     public abstract List getChildren();
 }