/*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you 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 org.apache.myfaces.shared.renderkit.html.util;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.FacesException;

 import javax.faces.application.ConfigurableNavigationHandler;

 import javax.faces.application.NavigationCase;

 import javax.faces.application.NavigationHandler;

 import javax.faces.application.ProjectStage;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIOutcomeTarget;

 import javax.faces.component.UIParameter;

 import javax.faces.context.FacesContext;

 import javax.faces.flow.FlowHandler;

 import javax.faces.lifecycle.ClientWindow;

 import org.apache.myfaces.shared.application.NavigationUtils;

 import org.apache.myfaces.shared.renderkit.JSFAttr;

 import org.apache.myfaces.shared.renderkit.RendererUtils;

 import org.apache.myfaces.shared.renderkit.html.HtmlRendererUtils;

 /**

  * Utility methods for OutcomeTarget components.

  */

 public class OutcomeTargetUtils

 {

     private static final Logger log = Logger.getLogger(OutcomeTargetUtils.class

             .getName());

     public static String getOutcomeTargetHref(FacesContext facesContext,

             UIOutcomeTarget component) throws IOException

     {

         String outcome = component.getOutcome();

         outcome = (outcome == null) ? facesContext.getViewRoot().getViewId()

                 : outcome;

         outcome = ((outcome == null) ? HtmlRendererUtils.STR_EMPTY : outcome.trim());

         // Get the correct URL for the outcome.

         NavigationHandler nh = facesContext.getApplication().getNavigationHandler();

         if (!(nh instanceof ConfigurableNavigationHandler))

         {

             throw new FacesException(

                     "Navigation handler must be an instance of "

                             + "ConfigurableNavigationHandler for using h:link or h:button");

         }

         ConfigurableNavigationHandler navigationHandler = (ConfigurableNavigationHandler) nh;

         // handle faces flow 

         // 1. check to-flow-document-id

         String toFlowDocumentId = (String) component.getAttributes().get(

             JSFAttr.TO_FLOW_DOCUMENT_ID_ATTR);

         // fromAction is null because there is no action method that was called to get the outcome

         NavigationCase navigationCase = null;

         if (toFlowDocumentId == null)

         {

             navigationCase = navigationHandler.getNavigationCase(

                 facesContext, null, outcome);

         }

         else

         {

             navigationCase = navigationHandler.getNavigationCase(

                 facesContext, null, outcome, toFlowDocumentId);            

         }

         // when navigation case is null, force the link or button to be disabled and log a warning

         if (navigationCase == null)

         {

             // log a warning

             log.warning("Could not determine NavigationCase for UIOutcomeTarget component "

                     + RendererUtils.getPathToComponent(component) + " with outcome " + outcome);

             return null;

         }

         Map<String, List<String>> parameters = null;

         // handle URL parameters

         if (component.getChildCount() > 0)

         {

             List<UIParameter> validParams = getValidUIParameterChildren(

                     facesContext, component.getChildren(), true, false);

             if (validParams.size() > 0)

             {

                 parameters = new HashMap<String, List<String>>();

             }

             for (int i = 0, size = validParams.size(); i < size; i++)

             {

                 UIParameter param = validParams.get(i);

                 String name = param.getName();

                 Object value = param.getValue();

                 if (parameters.containsKey(name))

                 {

                     parameters.get(name).add(value.toString());

                 }

                 else

                 {

                     List<String> list = new ArrayList<String>(1);

                     list.add(value.toString());

                     parameters.put(name, list);

                 }

             }

         }

         // From the navigation case, use getToFlowDocumentId() to identify when

         // a navigation case is a flow call or a flow return.

         if (navigationCase.getToFlowDocumentId() != null)

         {

             if (parameters == null)

             {

                 parameters = new HashMap<String, List<String>>();

             }

             if (!parameters.containsKey(FlowHandler.TO_FLOW_DOCUMENT_ID_REQUEST_PARAM_NAME))

             {

                 List<String> list = new ArrayList<String>(1);

                 list.add(navigationCase.getToFlowDocumentId());

                 parameters.put(FlowHandler.TO_FLOW_DOCUMENT_ID_REQUEST_PARAM_NAME, list);

             }

             if (!parameters.containsKey(FlowHandler.FLOW_ID_REQUEST_PARAM_NAME))

             {

                 List<String> list2 = new ArrayList<String>(1);

                 list2.add(navigationCase.getFromOutcome());

                 parameters.put(FlowHandler.FLOW_ID_REQUEST_PARAM_NAME, list2);

             }

         }

         // handle NavigationCase parameters

         Map<String, List<String>> navigationCaseParams = 

             NavigationUtils.getEvaluatedNavigationParameters(facesContext,

                 navigationCase.getParameters());

         if (navigationCaseParams != null)

         {

             if (parameters == null)

             {

                 parameters = new HashMap<String, List<String>>();

             }

             //parameters.putAll(navigationCaseParams);

             for (Map.Entry<String, List<String>> entry : navigationCaseParams

                     .entrySet())

             {

                 if (!parameters.containsKey(entry.getKey()))

                 {

                     parameters.put(entry.getKey(), entry.getValue());

                 }

             }

         }

         if (parameters == null)

         {

             parameters = Collections.emptyMap();

         }

         boolean disableClientWindow = component.isDisableClientWindow();

         ClientWindow clientWindow = facesContext.getExternalContext().getClientWindow();

         String href;

         try

         {

             if (clientWindow != null && disableClientWindow)

             {

                 clientWindow.disableClientWindowRenderMode(facesContext);

             }

             // In theory the precedence order to deal with params is this:

             // component parameters, navigation-case parameters, view parameters

             // getBookmarkableURL deal with this details.

             ViewHandler viewHandler = facesContext.getApplication().getViewHandler();

             href = viewHandler.getBookmarkableURL(facesContext,

                     navigationCase.getToViewId(facesContext),

                     parameters, navigationCase.isIncludeViewParams() || component.isIncludeViewParams());

         }

         finally

         {

             if (clientWindow != null && disableClientWindow)

             {

                 clientWindow.enableClientWindowRenderMode(facesContext);

             }

         }

         // handle fragment (viewId#fragment)

         String fragment = (String) component.getAttributes().get("fragment");

         if (fragment != null)

         {

             fragment = fragment.trim();

             if (fragment.length() > 0)

             {

                 href += "#" + fragment;

             }

         }

         return href;

     }

     /**

      * Calls getValidUIParameterChildren(facesContext, children, skipNullValue, skipUnrendered, true);

      *

      * @param facesContext

      * @param children

      * @param skipNullValue

      * @param skipUnrendered

      * @return ArrayList size > 0 if any parameter found

      */

     public static List<UIParameter> getValidUIParameterChildren(

             FacesContext facesContext, List<UIComponent> children,

             boolean skipNullValue, boolean skipUnrendered)

     {

         return getValidUIParameterChildren(facesContext, children,

                 skipNullValue, skipUnrendered, true);

     }

     /**

      * Returns a List of all valid UIParameter children from the given children.

      * Valid means that the UIParameter is not disabled, its name is not null

      * (if skipNullName is true), its value is not null (if skipNullValue is true)

      * and it is rendered (if skipUnrendered is true). This method also creates a

      * warning for every UIParameter with a null-name (again, if skipNullName is true)

      * and, if ProjectStage is Development and skipNullValue is true, it informs the

      * user about every null-value.

      *

      * @param facesContext

      * @param children

      * @param skipNullValue  should UIParameters with a null value be skipped

      * @param skipUnrendered should UIParameters with isRendered() returning false be skipped

      * @param skipNullName   should UIParameters with a null name be skipped

      *                       (normally true, but in the case of h:outputFormat false)

      * @return ArrayList size > 0 if any parameter found 

      */

     public static List<UIParameter> getValidUIParameterChildren(

             FacesContext facesContext, List<UIComponent> children,

             boolean skipNullValue, boolean skipUnrendered, boolean skipNullName)

     {

         List<UIParameter> params = null;

         for (int i = 0, size = children.size(); i < size; i++)

         {

             UIComponent child = children.get(i);

             if (child instanceof UIParameter)

             {

                 UIParameter param = (UIParameter) child;

                 // check for the disable attribute (since 2.0)

                 // and the render attribute (only if skipUnrendered is true)

                 if (param.isDisable() || (skipUnrendered && !param.isRendered()))

                 {

                     // ignore this UIParameter and continue

                     continue;

                 }

                 // check the name

                 String name = param.getName();

                 if (skipNullName && (name == null || HtmlRendererUtils.STR_EMPTY.equals(name)))

                 {

                     // warn for a null-name

                     log.log(Level.WARNING, "The UIParameter " + RendererUtils.getPathToComponent(param)

                                     + " has a name of null or empty string and thus will not be added to the URL.");

                     // and skip it

                     continue;

                 }

                 // check the value

                 if (skipNullValue && param.getValue() == null)

                 {

                     if (facesContext.isProjectStage(ProjectStage.Development))

                     {

                         // inform the user about the null value when in Development stage

                         log.log(Level.INFO, "The UIParameter " + RendererUtils.getPathToComponent(param)

                                         + " has a value of null and thus will not be added to the URL.");

                     }

                     // skip a null-value

                     continue;

                 }

                 // add the param

                 if (params == null)

                 {

                     params = new ArrayList<UIParameter>();

                 }

                 params.add(param);

             }

         }

         if (params == null)

         {

             params = Collections.emptyList();

         }

         return params;

     }

 }