/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.css2.layout;

import java.util.List;

import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.jst.pagedesigner.css2.ICSSStyle;
import org.eclipse.jst.pagedesigner.css2.property.ICSSPropertyID;
import org.eclipse.jst.pagedesigner.css2.property.PositionMeta;
import org.eclipse.jst.pagedesigner.css2.property.VerticalAlignMeta;
import org.eclipse.jst.pagedesigner.css2.value.Length;
import org.eclipse.jst.pagedesigner.ui.preferences.PDPreferences;

/**
 * CSSLayout is the base layout manager for different CSS layouts, such as block
 * layout, inline layout (possible in the future table layout, etc)
 * 
 * @author mengbo
 */
public abstract class CSSLayout extends FlowFigureLayout implements FlowContext {
	private BlockFlowContext _absoluteContext;

	// when doing absolute layout, and if top/left are both "auto", it will be
	// relating to the normaly flow position. The following two fields try to
	// catch normal flow layout position.
	// int _xForAbsolute;
	// int _yForAbsolute;
	private FlowBox _boxForAbsolute;

	/**
	 * the current line
	 */
	protected LineBox _currentLine;

	private boolean _calculatingMaxWidth = false;

	/**
	 * @param flowFigure 
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowFigureLayout#FlowFigureLayout(FlowFigure)
	 */
	protected CSSLayout(CSSFigure flowFigure) {
		super(flowFigure);
	}

	/**
	 * a shortcut method to get the style associated with the figure.
	 * 
	 * @return the css style
	 */
	public ICSSStyle getCSSStyle() {
		return getCSSFigure().getCSSStyle();
	}

	/**
	 * @return the absolute context
	 */
	protected final BlockFlowContext getAbsoluteContext() {
        return _absoluteContext;
    }

    /**
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#addToCurrentLine(FlowBox)
	 */
	public void addToCurrentLine(FlowBox block) {
		getCurrentLine().add(block);
	}

	/**
	 * Used by getCurrentLine().
	 */
	protected abstract void createNewLine();

	/**
	 * Used by getCurrentLine(int topmargin)
	 * 
	 * @param topMargin
	 */
	protected void createNewLine(int topMargin) {
		createNewLine();
	}

	/**
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#getCurrentLine()
	 */
	public LineBox getCurrentLine() {
		if (_currentLine == null) {
			createNewLine();
		}
		return _currentLine;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#getCurrentLine(int)
	 */
	public LineBox getCurrentLine(int topMargin) {
		if (_currentLine == null) {
			createNewLine(topMargin);
		}
		// if the current line only contains an empty string, reset the current
		// line using the given margin.
		else if (_currentLine.isEmptyStringLine()) {
			List list = _currentLine.getFragments();
			createNewLine(topMargin);
			_currentLine._fragments.addAll(list);
		}
		return _currentLine;
	}

	/**
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#isCurrentLineOccupied
	 */
	public boolean isCurrentLineOccupied() {
		return _currentLine != null && _currentLine.isOccupied();
	}

	/**
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowFigureLayout#layout()
	 */
	protected void layout() {
		preLayout();
		layoutChildren();
		flush();
		cleanup();
	}

	/**
	 * @return true if is absolute position
	 */
	protected final boolean isAbsolutePosition() {
		ICSSStyle style = getCSSStyle();

		// FIXME: Some layout don't support absolute, need check here
		if (style != null) {
			Object obj = style.getStyleProperty(ICSSPropertyID.ATTR_POSITION);
			if (PositionMeta.ABSOLUTE.equals(obj)
					|| PositionMeta.FIXED.equals(obj)) 
			{
			    PDPreferences prefs = new PDPreferences();
			    return prefs.isCssAbsolutePositioningEnabled();
			}
		}
		return false;
	}

	/**
	 * Child class could override this method.
	 * 
	 * @return true if supports absolute position  
	 */
	protected boolean supportAbsolutePosition() {
		if (findContainingPositionedFigure() == null) {
			return false;
		}
		return true;
	}

	/**
	 * Perform a prelayout
	 */
	protected void preLayout() {
		ICSSStyle style = this.getCSSStyle();
		if (style != null) {
			style.processCounters();
		}

		if (isAbsolutePosition()) {
			FlowContext parentFigureContext = getParentFigureContext();
			_absoluteContext = new BlockFlowContext(parentFigureContext, style);
			_boxForAbsolute = new FlowBox();// size is 0. Just as a flag, so
			// later we
			// could figure out where will this figure be
			// be put in case of not absolute
			_boxForAbsolute.setVerticalAlignData(VerticalAlignMeta.TOP);
			parentFigureContext.addToCurrentLine(_boxForAbsolute);
		} else {
			_absoluteContext = null;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowFigureLayout#getFlowContext()
	 */
	public FlowContext getFlowContext() {
		if (_absoluteContext != null) {
			return _absoluteContext;
		}
        return getOriginalFlowContext();
	}

	/**
	 * @return the flow context
	 */
	private FlowContext getParentFigureContext() {
		return super.getFlowContext();
	}

	final void postValidateForAbsolute() {
		if (_absoluteContext != null) {
			ICSSStyle style = this.getCSSStyle();

			_absoluteContext.endBlock();

			int xOffset;
			int yOffset;

			ICSSFigure containingPositionedFigure = findContainingPositionedFigure();
			IFigure parentFigure = this.getCSSFigure().getParent();

			xOffset = calculatePositionRelativeToParent(style,
					containingPositionedFigure, parentFigure, true);
			yOffset = calculatePositionRelativeToParent(style,
					containingPositionedFigure, parentFigure, false);
			move(_absoluteContext._blockBox, xOffset, yOffset);
		}
	}

	/**
	 * @param style
	 * @param containingPositionedFigure
	 * @param parentFigure
	 * @return
	 */
	private int calculatePositionRelativeToParent(ICSSStyle style,
			ICSSFigure containingPositionedFigure, IFigure parentFigure,
			boolean horizontal) {
		int xOffset;
		Object left = horizontal ? style
				.getStyleProperty(ICSSPropertyID.ATTR_LEFT) : style
				.getStyleProperty(ICSSPropertyID.ATTR_TOP);
		Object right = horizontal ? style
				.getStyleProperty(ICSSPropertyID.ATTR_RIGHT) : style
				.getStyleProperty(ICSSPropertyID.ATTR_BOTTOM);

		if (!(left instanceof Length) && !(right instanceof Length)) {
			// _boxForAbsolute partipated the layout of the parent figure, and
			// is already relative to parent.
			return horizontal ? _boxForAbsolute._x : _boxForAbsolute._y;
		}

		// ok, user specified left or right. let's calculate the left
		int leftValue;
		if (left instanceof Length) {
			Length leftLength = (Length) left;
			leftValue = leftLength.getValue();
			if (leftLength.isPercentage()) {
				leftValue = (horizontal ? containingPositionedFigure
						.getBounds().width : containingPositionedFigure
						.getBounds().height)
						* leftValue / 100;
			}
		} else {
			Length rightLength = (Length) right;
			int lengthValue = rightLength.getValue();
			if (rightLength.isPercentage()) {
				lengthValue = (horizontal ? containingPositionedFigure
						.getBounds().width : containingPositionedFigure
						.getBounds().height)
						* lengthValue / 100;
			}

			if (horizontal) {
				leftValue = containingPositionedFigure.getBounds().width
						- _absoluteContext._blockBox.getWidth() - lengthValue;
			} else {
				leftValue = containingPositionedFigure.getBounds().height
						- _absoluteContext._blockBox.getHeight() - lengthValue;
			}

		}

		// xOffset is relative to the first box of the containing figure
		List fragments = containingPositionedFigure
				.getFragmentsForRead();
		if (fragments.size() > 0) {
			FlowBox box = (FlowBox) fragments.get(0);
			// box._x is the x location relative to containingPositionedFigure's
			// parent.
			// so now xOffset is relative to containingPositionedFigure's
			// parent.
			xOffset = (horizontal ? box._x : box._y) + leftValue;
		} else {
			xOffset = leftValue; // should not happen.
		}
		Point p;
		if (horizontal) {
			p = new Point(xOffset, 0);
		} else {
			p = new Point(0, xOffset);
		}
		containingPositionedFigure.translateFromParent(p);
		containingPositionedFigure.translateToAbsolute(p);
		parentFigure.translateToRelative(p);
		return horizontal ? p.x : p.y;
	}

	/**
	 * @return
	 */
	private ICSSFigure findContainingPositionedFigure() {
		IFigure figure = this.getCSSFigure().getParent();
		while (figure instanceof ICSSFigure) {
			return (ICSSFigure) figure;
			// ICSSStyle style = ((ICSSFigure) figure).getCSSStyle();
			// if (DisplayToLayout.isPositioned(style))
			// {
			// return (ICSSFigure) figure;
			// }
			// figure = figure.getParent();
		}
		return null;

	}

	/**
	 * @param resultBox
	 * @param x
	 * @param y
	 */
	private void move(CompositeBox compBox, int x, int y) {
		compBox._x += x;
		compBox._y += y;
		List list = compBox.getFragments();
		for (int i = 0; i < list.size(); i++) {
			FlowBox box = (FlowBox) list.get(i);

			if (box instanceof CompositeBox && !(box instanceof BlockBox)) {
				move((CompositeBox) box, x, y);
			} else {
				box._x += x;
				box._y += y;
			}
		}
	}

	/**
	 * Layout all children.
	 */
	protected void layoutChildren() {
		List children = getFlowFigure().getChildren();
		for (int i = 0; i < children.size(); i++) {
			Figure f = (Figure) children.get(i);
			f.invalidate();
			f.validate();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#getLastMarginRight()
	 */
	public int getLastMarginRight() {
		if (_currentLine == null || !_currentLine.isOccupied()) {
			return 0;
		}
		FlowBox box = (FlowBox) _currentLine.getFragments().get(
				_currentLine.getFragments().size() - 1);
		if (box != null) {
			return box.getMarginInsets().right;
		}
        return 0;
	}

	/**
	 * @param c
	 */
	public void setCalculatingMaxWidth(boolean c) {
		_calculatingMaxWidth = c;
	}

	/**
	 * @return the calculated maximum width
	 */
	public boolean getCalcuatingMaxWidth() {
		return _calculatingMaxWidth;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.pagedesigner.css2.layout.FlowContext#isCalculatingMaxWidth()
	 */
	public boolean isCalculatingMaxWidth() {
		if (_calculatingMaxWidth) {
			return true;
		} else if (this.getFlowContext() == null) {
			return false;
		} else {
			return this.getFlowContext().isCalculatingMaxWidth();
		}
	}

	/**
	 * Called after {@link #layoutChildren()}when all children have been laid
	 * out. This method exists to flush the last line.
	 */
	protected abstract void flush();

	/**
	 * Flush anything pending and free all temporary data used during layout.
	 */
	protected abstract void cleanup();

	// ------------------------------------------------------------------------------------

	/**
	 * @return the css figure
	 */
	protected final CSSFigure getCSSFigure() {
		return (CSSFigure) getFlowFigure();
	}

	/**
	 * 
	 * @return the fragments for read
	 */
	public abstract List getFragmentsForRead();

	/**
	 * postValidate the child figures of this CSSFigure. Normally layout fall
	 * into the first category need implement this method.
	 */
	public abstract void postValidate();

	/**
	 * setBounds is called on the CSSFigure. Normally layout fall into the
	 * second category need implement this method.
	 * 
	 * @param rect
	 * @param invalidate
	 */
	public void setBoundsCalled(Rectangle rect, boolean invalidate) {
        // TODO: dead?
	}

	/**
	 * Child class can override this. Normally block figure will return true.
	 * 
	 * @return true if should use local coordinates
	 */
	protected boolean useLocalCoordinates() {
		return false;
	}

	/**
	 * If CSSLayout will call paint rountine to draw Border for its box, this
	 * method will return true, else return false, for example,the input file
	 * will return false.
	 * 
	 * @return true if handling border block
	 */
	protected boolean handlingBorderForBlock() {
		return true;
	}

	/**
	 * This method is called when the corresponding figure is revalidated.
	 * 
	 */
	protected void figureRevalidate() {
		// child class can override.
	}
}