/*
    * 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.tobago.internal.component;
  
  import org.apache.myfaces.tobago.component.Attributes;
  import org.apache.myfaces.tobago.internal.layout.Grid;
  import org.apache.myfaces.tobago.internal.layout.IntervalList;
  import org.apache.myfaces.tobago.internal.layout.LayoutUtils;
  import org.apache.myfaces.tobago.internal.layout.OriginCell;
  import org.apache.myfaces.tobago.internal.util.StringUtils;
  import org.apache.myfaces.tobago.layout.AutoLayoutToken;
  import org.apache.myfaces.tobago.layout.Display;
  import org.apache.myfaces.tobago.layout.LayoutBox;
  import org.apache.myfaces.tobago.layout.LayoutComponent;
  import org.apache.myfaces.tobago.layout.LayoutContainer;
  import org.apache.myfaces.tobago.layout.LayoutManager;
  import org.apache.myfaces.tobago.layout.LayoutToken;
  import org.apache.myfaces.tobago.layout.LayoutTokens;
  import org.apache.myfaces.tobago.layout.Measure;
  import org.apache.myfaces.tobago.layout.Orientation;
  import org.apache.myfaces.tobago.layout.RelativeLayoutToken;
  import org.apache.myfaces.tobago.model.SheetState;
  import org.apache.myfaces.tobago.renderkit.LayoutComponentRenderer;
  import org.apache.myfaces.tobago.util.LayoutInfo;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.faces.component.UIColumn;
  import javax.faces.component.UIComponent;
  import javax.faces.context.FacesContext;
  import java.util.List;
  import java.util.Map;
  
  /**
   * XXX: Not completely implemented yet.
   */ 
  public abstract class AbstractUISheetLayout extends AbstractUILayoutBase implements LayoutManager {
  
    private static final Logger LOG = LoggerFactory.getLogger(AbstractUISheetLayout.class);
  
    private boolean horizontalAuto;
    private boolean verticalAuto;
  
    public void init() {
  
      layoutHeader();
  
      for (LayoutComponent component : getLayoutContainer().getComponents()) {
        if (component instanceof LayoutContainer) {
          ((LayoutContainer) component).getLayoutManager().init();
        }
      }
    }
  
    public void fixRelativeInsideAuto(Orientation orientation, boolean auto) {
  
      if (orientation == Orientation.HORIZONTAL) {
        horizontalAuto = auto;
      } else {
        verticalAuto = auto;
      }
  
      for (LayoutComponent component : getLayoutContainer().getComponents()) {
        if (component instanceof LayoutContainer) {
          ((LayoutContainer) component).getLayoutManager().fixRelativeInsideAuto(orientation, auto);
        }
      }
    }
  
    public void preProcessing(Orientation orientation) {
  
      // process auto tokens
      IntervalList intervals = new IntervalList();
      for (LayoutComponent component : getLayoutContainer().getComponents()) {
  
        if (component != null) {
          if (component instanceof LayoutContainer) {
            ((LayoutContainer) component).getLayoutManager().preProcessing(orientation);
          }
  
  /*
          if (orientation == Orientation.HORIZONTAL && horizontalAuto
             || orientation == Orientation.VERTICAL && verticalAuto) {
           intervals.add(new Interval(component, orientation));
         }
 */
       }
     }
 
 /*
     if (intervals.size() >= 1) {
       intervals.evaluate();
       Measure size = intervals.getCurrent();
       size = size.add(LayoutUtils.getBorderBegin(orientation, getLayoutContainer()));
       size = size.add(LayoutUtils.getBorderEnd(orientation, getLayoutContainer()));
       LayoutUtils.setCurrentSize(orientation, getLayoutContainer(), size);
     }
 */
   }
 
   public void mainProcessing(Orientation orientation) {
 
     // find *
     if (orientation == Orientation.HORIZONTAL && !horizontalAuto 
         || orientation == Orientation.VERTICAL && !verticalAuto) {
 
       final FacesContext facesContext = FacesContext.getCurrentInstance();
       final LayoutContainer container = getLayoutContainer();
       final AbstractUISheet sheet = (AbstractUISheet) container;
 
       if (orientation == Orientation.HORIZONTAL) {
 
         ensureColumnWidthList(facesContext, sheet);
 
         final List<Integer> widthList = sheet.getWidthList();
 
         int index = 0;
         for (LayoutComponent component : sheet.getComponents()) {
           if (component == null) {
             LOG.error("fixme: UIColumnSelector must be a LayoutComponent!"); // fixme
             index++;
             continue;
           }
           final UIColumn column = component instanceof AbstractUIColumnNode
               ? (UIColumn) component
               : (UIColumn) ((UIComponent) component).getParent();
           if (!column.isRendered()) {
             // XXX here not index++, because the widthList has only the rendered=true, todo: change it.
             continue;
           }
           if (column instanceof LayoutBox) {
             LayoutBox box = (LayoutBox) column;
             Measure width = Measure.valueOf(widthList.get(index));
             width = width.subtractNotNegative(LayoutUtils.getBorderBegin(orientation, box));
             width = width.subtractNotNegative(LayoutUtils.getPaddingBegin(orientation, box));
             width = width.subtractNotNegative(LayoutUtils.getPaddingEnd(orientation, box));
             width = width.subtractNotNegative(LayoutUtils.getBorderEnd(orientation, box));
             final LayoutComponentRenderer renderer = sheet.getLayoutComponentRenderer(facesContext);
             width = width.subtractNotNegative(renderer.getCustomMeasure(facesContext, sheet, "columnSeparator"));
             LayoutUtils.setCurrentSize(orientation, component, width);
             component.setDisplay(Display.BLOCK); // TODO: use CSS via classes and tobago.css
             // call sub layout manager
             if (component instanceof LayoutContainer) {
               ((LayoutContainer) component).getLayoutManager().mainProcessing(orientation);
             }
           }
           index++;
         }
       }
     }
   }
 
   public void postProcessing(Orientation orientation) {
 
     final AbstractUISheet sheet = (AbstractUISheet) getLayoutContainer();
 
     // set positions to all sub-layout-managers
 
     for (LayoutComponent component : sheet.getComponents()) {
 
       if (component != null) {
         // compute the position of the cell
         Measure position = LayoutUtils.getBorderBegin(orientation, sheet);
         if (orientation == Orientation.HORIZONTAL) {
           component.setLeft(position);
         } else {
           component.setTop(position);
         }
 
         // call sub layout manager
         if (component instanceof LayoutContainer) {
           ((LayoutContainer) component).getLayoutManager().postProcessing(orientation);
         }
 
         // todo: optimize: the AutoLayoutTokens with columnSpan=1 are already called
       }
     }
   }
 
   private LayoutContainer getLayoutContainer() {
     // todo: check with instanceof and do something in the error case
     return ((LayoutContainer) getParent());
   }
 
   @Override
   public boolean getRendersChildren() {
     return false;
   }
 
   private void ensureColumnWidthList(FacesContext facesContext, AbstractUISheet data) {
     List<Integer> currentWidthList = null;
     // TODO: Refactor: here be should use "getColumns()" instead of "getRenderedColumns()"
     List<AbstractUIColumn> renderedColumns = data.getRenderedColumns();
 
     final Map attributes = data.getAttributes();
     String widthListString = null;
     SheetState state = data.getSheetState(facesContext);
     if (state != null) {
       widthListString = state.getColumnWidths();
     }
     if (widthListString == null) {
       widthListString = (String) attributes.get(Attributes.WIDTH_LIST_STRING);
     }
 
     if (widthListString != null) {
       try {
         currentWidthList = StringUtils.parseIntegerList(widthListString);
       } catch (NumberFormatException e) {
         LOG.warn("Unexpected value for column width list: '" + widthListString + "'");
       }
     }
     if (currentWidthList != null && currentWidthList.size() != renderedColumns.size() + 1) {
       currentWidthList = null;
     }
 
     if (currentWidthList == null) {
       LayoutTokens tokens = data.getColumnLayout();
       List<AbstractUIColumn> allColumns = data.getAllColumns();
       LayoutTokens newTokens = new LayoutTokens();
       for (int i = 0; i < allColumns.size(); i++) {
         AbstractUIColumn column = allColumns.get(i);
         if (column.isRendered()) {
           if (tokens == null) {
             if (column instanceof AbstractUIColumn && column.getWidth() != null) {
               newTokens.addToken(LayoutTokens.parseToken(column.getWidth().serialize()));
             } else {
               newTokens.addToken(RelativeLayoutToken.DEFAULT_INSTANCE);
             }
           } else {
             if (i < tokens.getSize()) {
               newTokens.addToken(tokens.get(i));
             } else {
               newTokens.addToken(RelativeLayoutToken.DEFAULT_INSTANCE);
             }
           }
         }
       }
 
       Measure space = data.getCurrentWidth();
       final LayoutComponentRenderer renderer = data.getLayoutComponentRenderer(facesContext);
       space = space.subtractNotNegative(renderer.getBorderLeft(facesContext, data));
       space = space.subtractNotNegative(renderer.getBorderRight(facesContext, data));
       if (needVerticalScrollbar(facesContext, data)) {
         space = space.subtractNotNegative(renderer.getVerticalScrollbarWeight(facesContext, data));
       }
 /*
       // todo: not nice: 1 left + 1 right border
       space = space.subtract(renderedColumns.size() * 2);
 */
       LayoutInfo layoutInfo =
           new LayoutInfo(newTokens.getSize(), space.getPixel(), newTokens, data.getClientId(facesContext), false);
       final Measure columnSelectorWidth
           = data.getLayoutComponentRenderer(facesContext).getCustomMeasure(facesContext, data, "columnSelectorWidth");
       parseFixedWidth(layoutInfo, renderedColumns, columnSelectorWidth);
       layoutInfo.parseColumnLayout(space.getPixel());
       currentWidthList = layoutInfo.getSpaceList();
       currentWidthList.add(0); // empty filler column
     }
 
     if (renderedColumns.size() + 1 != currentWidthList.size()) {
       LOG.warn("widthList.size() = " + currentWidthList.size()
           + " != columns.size() = " + renderedColumns.size() + " + 1. The widthList: "
           + LayoutInfo.listToTokenString(currentWidthList));
     } else {
       data.setWidthList(currentWidthList);
     }
   }
 
   private boolean needVerticalScrollbar(FacesContext facesContext, AbstractUISheet sheet) {
     // estimate need of height-scrollbar on client, if yes we have to consider
     // this when calculating column width's
 
     if (sheet.getNeedVerticalScrollbar() != null) {
       return sheet.getNeedVerticalScrollbar();
     }
 
     Boolean result = null;
 
     final Object forceScrollbar = sheet.getAttributes().get(Attributes.FORCE_VERTICAL_SCROLLBAR);
     if (forceScrollbar != null) {
       if ("true".equals(forceScrollbar)) {
         result = true;
       } else if ("false".equals(forceScrollbar)) {
         result = false;
       } else if (!"auto".equals(forceScrollbar)) {
         LOG.warn("Illegal value for attribute 'forceVerticalScrollbar': '" + forceScrollbar + "'");
       }
     }
 
     if (result == null && !sheet.hasRowCount()) {
       result = true;
     }
 
     if (result == null) {
       if (sheet.getCurrentHeight() != null) {
         int first = sheet.getFirst();
         int rows = sheet.isRowsUnlimited()
             ? sheet.getRowCount()
             : Math.min(sheet.getRowCount(), first + sheet.getRows()) - first;
         Measure heightNeeded = getRowHeight(facesContext, sheet).multiply(rows);
         if (sheet.isShowHeader()) {
           heightNeeded = heightNeeded.add(getHeaderHeight(facesContext, sheet));
         }
         if (sheet.isPagingVisible()) {
           heightNeeded = heightNeeded.add(getFooterHeight(facesContext, sheet));
         }
         result = heightNeeded.greaterThan(sheet.getCurrentHeight());
       } else {
         result = false;
       }
     }
     sheet.setNeedVerticalScrollbar(result);
     return result;
   }
 
   private void parseFixedWidth(
       LayoutInfo layoutInfo, List<AbstractUIColumn> renderedColumns, Measure columnSelectorWidth) {
     LayoutTokens tokens = layoutInfo.getLayoutTokens();
     for (int i = 0; i < tokens.getSize(); i++) {
       LayoutToken token = tokens.get(i);
       if (token instanceof AutoLayoutToken) {
         int width = 0;
         if (!renderedColumns.isEmpty()) {
           if (i < renderedColumns.size()) {
             AbstractUIColumn column = renderedColumns.get(i);
             if (column instanceof AbstractUIColumnSelector) {
               width = columnSelectorWidth.getPixel();
             } else {
               for (UIComponent component : column.getChildren()) {
                 width += 100; // FIXME: make dynamic (was removed by changing the layout
                 LOG.error("100; // FIXME: make dynamic (was removed by changing the layout");
               }
             }
             layoutInfo.update(width, i);
           } else {
             layoutInfo.update(0, i);
             if (LOG.isWarnEnabled()) {
               LOG.warn("More LayoutTokens found than rows! skipping!");
             }
           }
         }
         if (LOG.isDebugEnabled()) {
           LOG.debug("set column " + i + " from 'auto' to width " + width);
         }
       }
     }
   }
 
   private Measure getHeaderHeight(FacesContext facesContext, AbstractUISheet sheet) {
     return sheet.isShowHeader()
         ? sheet.getLayoutComponentRenderer(facesContext).getCustomMeasure(facesContext, sheet, "headerHeight")
         : Measure.ZERO;
   }
 
   private Measure getRowHeight(FacesContext facesContext, AbstractUISheet sheet) {
     return sheet.getLayoutComponentRenderer(facesContext).getCustomMeasure(facesContext, sheet, "rowHeight");
   }
 
   private Measure getFooterHeight(FacesContext facesContext, AbstractUISheet sheet) {
     return sheet.isPagingVisible()
         ? sheet.getLayoutComponentRenderer(facesContext).getCustomMeasure(facesContext, sheet, "footerHeight")
         : Measure.ZERO;
   }
 
   private void layoutHeader() {
     final AbstractUISheet sheet = (AbstractUISheet) getLayoutContainer();
     final UIComponent header = sheet.getHeader();
     final LayoutTokens columns = new LayoutTokens();
     final List<AbstractUIColumn> renderedColumns = sheet.getRenderedColumns();
     for (AbstractUIColumn ignored : renderedColumns) {
       columns.addToken(RelativeLayoutToken.DEFAULT_INSTANCE);
     }
     final LayoutTokens rows = new LayoutTokens();
     rows.addToken(AutoLayoutToken.INSTANCE);
     final Grid grid = new Grid(columns, rows);
 
     for(UIComponent child : header.getChildren()) {
       if (child instanceof LayoutComponent) {
         final LayoutComponent c = (LayoutComponent) child;
         grid.add(new OriginCell(c), c.getColumnSpan(), c.getRowSpan());
       } else {
         if (LOG.isDebugEnabled()) {
           LOG.debug("Found unknown component in header.");
         }
       }
     }
     sheet.setHeaderGrid(grid);
   }
 }