/*

  * 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.Iterator;

 import java.util.List;

 import java.util.Set;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UISelectItems;

 import javax.faces.component.UISelectMany;

 import javax.faces.component.UISelectOne;

 import javax.faces.context.FacesContext;

 import javax.faces.context.ResponseWriter;

 import javax.faces.convert.Converter;

 import javax.faces.model.SelectItem;

 import javax.faces.model.SelectItemGroup;

 import org.apache.myfaces.shared.component.EscapeCapable;

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

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

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

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

 import org.apache.myfaces.shared.util.SelectItemsIterator;

 /**

  * Utility methods to manipulate SelectItem/SelectItems

  */

 public class SelectItemsUtils

 {

     private static final char TABULATOR = '\t';

     public static List<SelectItemInfo> getSelectItemInfoList(UISelectMany uiSelectMany,

             FacesContext facesContext)

     {

         List<SelectItemInfo> list = new ArrayList<SelectItemInfo>();

         for (SelectItemsIterator iter = new SelectItemsIterator(uiSelectMany, facesContext); iter

                 .hasNext();)

         {

             list.add(new SelectItemInfo(iter.next(), iter.getCurrentComponent(), iter.getCurrentValue()));

         }

         return list;

     }

     public static List<SelectItemInfo> getSelectItemInfoList(UISelectOne uiSelectOne,

             FacesContext facesContext)

     {

         List<SelectItemInfo> list = new ArrayList<SelectItemInfo>();

         for (SelectItemsIterator iter = new SelectItemsIterator(uiSelectOne, facesContext); iter

                 .hasNext();)

         {

             list.add(new SelectItemInfo(iter.next(), iter.getCurrentComponent(), iter.getCurrentValue()));

         }

         return list;

     }

 public static void renderSelectOptions(FacesContext context,

             UIComponent component, Converter converter, Set lookupSet,

             List<SelectItemInfo> selectItemList) throws IOException

     {

         ResponseWriter writer = context.getResponseWriter();

         // check for the hideNoSelectionOption attribute

         boolean hideNoSelectionOption = isHideNoSelectionOption(component);

         boolean componentDisabled = isTrue(component.getAttributes()

                 .get("disabled"));

         for (Iterator<SelectItemInfo> it = selectItemList.iterator(); it.hasNext();)

         {

             SelectItemInfo selectItemInfo = it.next();

             SelectItem selectItem = selectItemInfo.getItem();

             if (selectItem instanceof SelectItemGroup)

             {

                 writer.startElement(HTML.OPTGROUP_ELEM, selectItemInfo.getComponent()); // component);

                 writer.writeAttribute(HTML.LABEL_ATTR, selectItem.getLabel(),

                         null);

                 SelectItem[] selectItems = ((SelectItemGroup) selectItem)

                         .getSelectItems();

                 List<SelectItemInfo> selectItemsGroupList = new ArrayList<SelectItemInfo>(selectItems.length);

                 for (SelectItem item : selectItems)

                 {

                     selectItemsGroupList.add(new SelectItemInfo(item, null));

                 }

                 renderSelectOptions(context, component, converter, lookupSet,

                         selectItemsGroupList);

                 writer.endElement(HTML.OPTGROUP_ELEM);

             }

             else

             {

                 String itemStrValue = org.apache.myfaces.shared.renderkit.RendererUtils

                         .getConvertedStringValue(context, component, converter,

                                 selectItem);

                 boolean selected = lookupSet.contains(itemStrValue); 

                 //TODO/FIX: we always compare the String vales, better fill lookupSet with Strings 

                 //only when useSubmittedValue==true, else use the real item value Objects

                 // IF the hideNoSelectionOption attribute of the component is true

                 // AND this selectItem is the "no selection option"

                 // AND there are currently selected items 

                 // AND this item (the "no selection option") is not selected

                 // (if there is currently no value on UISelectOne, lookupSet contains "")

                 if (hideNoSelectionOption && selectItem.isNoSelectionOption()

                         && lookupSet.size() != 0

                         && !(lookupSet.size() == 1 && lookupSet.contains(""))

                         && !selected)

                 {

                     // do not render this selectItem

                     continue;

                 }

                 writer.write(TABULATOR);

                 boolean wroteRequestMapVarValue = false;

                 Object oldRequestMapVarValue = null;

                 String var = null;

                 if (selectItemInfo != null && selectItemInfo.getComponent() instanceof UISelectItems)

                 {

                     var = (String) selectItemInfo.getComponent().getAttributes().get(JSFAttr.VAR_ATTR);

                     if(var != null && !"".equals(var))

                     {

                         // save the current value of the key listed in var from the request map

                         oldRequestMapVarValue = context.getExternalContext().getRequestMap().put(var, 

                                 selectItemInfo.getValue());

                         wroteRequestMapVarValue = true;

                     }

                 }

                 writer.startElement(HTML.OPTION_ELEM, selectItemInfo.getComponent()); // component);

                 if (itemStrValue != null)

                 {

                     writer.writeAttribute(HTML.VALUE_ATTR, itemStrValue, null);

                 }

                 else

                 {

                     writer.writeAttribute(HTML.VALUE_ATTR, "", null);

                 }

                 if (selected)

                 {

                     writer.writeAttribute(HTML.SELECTED_ATTR, HTML.SELECTED_ATTR, null);

                 }

                 boolean disabled = selectItem.isDisabled();

                 if (disabled)

                 {

                     writer.writeAttribute(HTML.DISABLED_ATTR, HTML.DISABLED_ATTR, null);

                 }

                 String labelClass = null;

                 if (componentDisabled || disabled)

                 {

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

                             JSFAttr.DISABLED_CLASS_ATTR);

                 }

                 else

                 {

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

                             JSFAttr.ENABLED_CLASS_ATTR);

                 }

                 if (labelClass != null)

                 {

                     writer.writeAttribute("class", labelClass, "labelClass");

                 }

                 boolean escape;

                 if (component instanceof EscapeCapable)

                 {

                     escape = ((EscapeCapable) component).isEscape();

                     // Preserve tomahawk semantic. If escape=false

                     // all items should be non escaped. If escape

                     // is true check if selectItem.isEscape() is

                     // true and do it.

                     // This is done for remain compatibility.

                     if (escape && selectItem.isEscape())

                     {

                         writer.writeText(selectItem.getLabel(), null);

                     }

                     else

                     {

                         writer.write(selectItem.getLabel());

                     }

                 }

                 else

                 {

                     escape = RendererUtils.getBooleanAttribute(component,

                             JSFAttr.ESCAPE_ATTR, false);

                     //default is to escape

                     //In JSF 1.2, when a SelectItem is created by default 

                     //selectItem.isEscape() returns true (this property

                     //is not available on JSF 1.1).

                     //so, if we found a escape property on the component

                     //set to true, escape every item, but if not

                     //check if isEscape() = true first.

                     if (escape || selectItem.isEscape())

                     {

                         writer.writeText(selectItem.getLabel(), null);

                     }

                     else

                     {

                         writer.write(selectItem.getLabel());

                     }

                 }

                 writer.endElement(HTML.OPTION_ELEM);

                 // remove the value with the key from var from the request map, if previously written

                 if(wroteRequestMapVarValue)

                 {

                     // If there was a previous value stored with the key from var in the request map, restore it

                     if (oldRequestMapVarValue != null)

                     {

                         context.getExternalContext()

                                 .getRequestMap().put(var, oldRequestMapVarValue);

                     }

                     else

                     {

                         context.getExternalContext()

                                 .getRequestMap().remove(var);

                     }

                 }

             }

         }

     }

     private static boolean isTrue(Object obj)

     {

         if (obj instanceof String)

         {

             return Boolean.valueOf((String) obj);

         }

         if (!(obj instanceof Boolean))

         {

             return false;

         }

         return ((Boolean) obj).booleanValue();

     }

 }