package pt.ist.renderers.extensions;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import pt.ist.fenixframework.DomainObject;
import pt.ist.renderers.OutputRenderer;
import pt.ist.renderers.components.HtmlBlockContainer;
import pt.ist.renderers.components.HtmlComponent;
import pt.ist.renderers.components.HtmlContainer;
import pt.ist.renderers.components.HtmlImage;
import pt.ist.renderers.components.HtmlInlineContainer;
import pt.ist.renderers.components.HtmlLink;
import pt.ist.renderers.components.HtmlList;
import pt.ist.renderers.components.HtmlListItem;
import pt.ist.renderers.components.HtmlScript;
import pt.ist.renderers.components.HtmlStyle;
import pt.ist.renderers.components.HtmlText;
import pt.ist.renderers.layouts.Layout;
import pt.ist.renderers.schemas.Schema;
import pt.ist.renderers.utils.RenderKit;
import pt.ist.renderers.utils.RenderUtils;
import pt.ist.renderers.utils.RendererPropertyUtils;

/**
 * This renderer is a generic renderer that can be used to display simple list or tree views.
 * The usual way of using this renderer includes the configuration of the presentation of 
 * each item and the indication of how to get the children of each item. Additionaliy you
 * can specify control link that target each item.
 * 
 * <p>
 * The <tt>TreeRenderer</tt> also offers the possibility to include images in each items
 * and make the tree draggable using javascript. If you need a draggable tree then you
 * must choose a {@link #setTreeId(String) treeId} and a {@link #setFieldId(String) fieldId} 
 * or a{@link #setSaveUrl(String) saveUrl}.
 * 
 * <p>
 * You can also configure the style and class of several elements in the tree. You must
 * give special attention to the class you choose for the list items because when the tree
 * is draggable those classes have a special meaning. 
 * 
 * <p>
 * Example: 
 * <ul>
 *  <li>item 1</li>
 *  <li>item 2
 *      <ul>
 *          <li>item 2.1</li>
 *          <li>item 2.2</li>
 *      </ul>
 *  </li>
 *  <li>item 3
 *      <ul>
 *          <li>item 3.1</li>
 *          <li>item 3.2</li>
 *      </ul>
 *  </li>
 *  <li>item 4</li>
 * 
 * @author cfgi
 * 
 * @see #setChildren(String)
 * @see #setChildrenFor(String, String)
 * @see #setTreeId(String)
 * @see #setFieldId(String)
 * @see #setSaveUrl(String)
 */
public class TreeRenderer extends OutputRenderer {

    private String treeId;

    private boolean expandable;
    private String fieldId;
    private String saveUrl;
    private boolean moduleRelative;
    private String saveParameter;
    private String onComplete;
    private String onError;

    private String eachLayout;
    private String eachSchema;

    private String image;
    private String children;
    private String links;
    private String hiddenLinks;
    private boolean includeImage;

    private String listClass;
    private String listStyle;
    private String itemClass;
    private String itemStyle;
    private String linksClasses;
    private String linksStyle;

    private String movedClass;

    private final Map<String, String> layoutsMap;
    private final Map<String, String> schemasMap;

    private final Map<String, String> childrenMap;
    private final Map<String, String> noChildrenMap;
    private final Map<String, String> classesMap;
    private final Map<String, String> styleMap;
    private final Map<String, String> linksMap;
    private final Map<String, String> hiddenLinksMap;
    private final Map<String, String> imagesMap;

    private LevelDecorator decorator;

    private String current;
    private String currentClasses;
    private String currentStyle;

    public TreeRenderer() {
	super();

	this.childrenMap = new HashMap<String, String>();
	this.noChildrenMap = new HashMap<String, String>();
	this.classesMap = new HashMap<String, String>();
	this.styleMap = new HashMap<String, String>();
	this.linksMap = new HashMap<String, String>();
	this.hiddenLinksMap = new HashMap<String, String>();
	this.imagesMap = new HashMap<String, String>();
	this.layoutsMap = new HashMap<String, String>();
	this.schemasMap = new HashMap<String, String>();

	setStyle("margin: 0px; padding: 0px;");
	setListStyle("margin-left: 20px; padding-left: 20px;");
	setItemStyle("vertical-align:middle;");

	setModuleRelative(true);
	setIncludeImage(true);
    }

    public String getTreeId() {
	return this.treeId;
    }

    /**
     * Chooses the id of the generated tree. This property is required when you want the
     * tree to be draggable. When the tree is generated a javaScript object with this
     * id is generated so you have to specify a valid javascript identifier.
     * 
     * <p>
     * The given identifier can be used in javascript to invoke operations in the tree.
     * The most important are:
     * 
     * <ul>
     *  <li><strong><tt>treeRenderer_saveTree(<em>id</em>)</tt></strong>: submits the current tree structure to be saved</li>
     *  <li><strong><tt>treeRenderer_expandAll(<em>id</em>)</tt></strong>: expands all nodes of the tree</li>
     *  <li><strong><tt>treeRenderer_collapseAll(<em>id</em>)</tt></strong>: collapse all nodes of the tree</li>
     * </ul>
     * 
     * @property
     */
    public void setTreeId(String treeId) {
	this.treeId = treeId;
    }

    public String getEachLayout() {
	return this.eachLayout;
    }

    /**
     * Chooses the default layout that should be used to present each item.
     * 
     * @property
     */
    public void setEachLayout(String eachLayout) {
	this.eachLayout = eachLayout;
    }

    public String getEachSchema() {
	return this.eachSchema;
    }

    /**
     * Chooses the default schema that should be used when presenting each item.
     * 
     * @property
     */
    public void setEachSchema(String eachSchema) {
	this.eachSchema = eachSchema;
    }

    public String getFieldId() {
	return this.fieldId;
    }

    public String getLayoutFor(String type) {
	return this.layoutsMap.get(type);
    }

    /**
     * Chooses the layout to be used to presente objects of the specified type. You
     * can use the simple name of the type.
     *
     * @property
     */
    public void setLayoutFor(String type, String layout) {
	this.layoutsMap.put(type, layout);
    }

    public String getSchemaFor(String type) {
	return this.schemasMap.get(type);
    }

    /**
     * Chooses the schema to be used when presenting objects of the specified type. You
     * can use the simple name of the type.
     *
     * @property
     */
    public void setSchemaFor(String type, String schema) {
	this.schemasMap.put(type, schema);
    }

    public String getChildren() {
	return this.children;
    }

    /**
     * This property specifies the name of the method that should be used, by default, to
     * obtain the list of children for each item. If             this property is not specified then,
     * by default, items are considered to be leaf items.
     * 
     * @property
     */
    public void setChildren(String children) {
	this.children = children;
    }

    public String getChildrenFor(String type) {
	return this.childrenMap.get(type);
    }

    /**
     * Allows you to filter some subclasses and avoid them to have children.
     * 
     * @property
     */
    public void setNoChildrenFor(String type, String value) {
	this.noChildrenMap.put(type, value);
    }

    public String getNoChildrenFor(String type) {
	return this.noChildrenMap.get(type);
    }

    /**
     * This property specifies the name of the method that should be used to obtain the
     * list of children for item that are objects of the specified type. You can use
     * the simple name or the complete type name if there are naem conflicts.
     * 
     * @property
     */
    public void setChildrenFor(String type, String method) {
	this.childrenMap.put(type, method);
    }

    /**
     * This property indicates two things. First it indicates that you want a draggable
     * tree. Second it specifies the id of the form field were the tree structure will
     * be saved when you invoke the <tt>saveTree()</tt> operation of the tree.
     * 
     * <p>
     * Note that the form containing the field will be automatically submitted. So you
     * can have a form somewere in the page that looks like:
     * 
     * <pre>
     *  &lt;form action=&quot;/someAction.do&quot;&gt;
     *      &lt;input id=&quot;myFieldId&quot; type=&quot;hidden&quot; name=&quot;tree&quot; value=&quot;&quot;/&gt; 
     *  &lt;/form&gt;
     * </pre>
     * 
     * @property
     */
    public void setFieldId(String fieldId) {
	this.fieldId = fieldId;
    }

    public String getSaveUrl() {
	return this.saveUrl;
    }

    /**
     * This property is similar to {@link #setFieldId(String) fieldId}, that is, is also 
     * specifies that you want a draggable tree. Nevertheless when you specify this propert
     * instead of the {@link #setFieldId(String) fieldId} the tree is saved is asynchronous
     * way to the server to the url indicated in this property.
     * 
     * @see #setOnComplete(String)
     * @see #setOnError(String)
     * @see #setSaveParameter(String)
     * @see #setModuleRelative(boolean)
     * 
     * @property
     */
    public void setSaveUrl(String saveUrl) {
	this.saveUrl = saveUrl;
    }

    public boolean isModuleRelative() {
	return this.moduleRelative;
    }

    /**
     * This property indicates if the <tt>saveUrl</tt> is relative to the current module.
     * This property is <code>true</code> by default.
     *  
     * @property
     */
    public void setModuleRelative(boolean moduleRelative) {
	this.moduleRelative = moduleRelative;
    }

    public String getSaveParameter() {
	return this.saveParameter;
    }

    /**
     * When the tree is saved in an asynchronous way this property chooses the name of the
     * parameter that will contain the tree structure.
     * 
     * @property
     */
    public void setSaveParameter(String saveParameter) {
	this.saveParameter = saveParameter;
    }

    public String getOnComplete() {
	return this.onComplete;
    }

    /**
     * This property specifies the javascript function to be executed when the tree structure 
     * is saved correctly, that is, submited without protocol errors to the server. You
     * can specify an anonymous function like <tt>function() { alert('complete'); }</tt>
     * 
     * @property
     */
    public void setOnComplete(String onComplete) {
	this.onComplete = onComplete;
    }

    public String getOnError() {
	return this.onError;
    }

    /**
     * This property specifies the javascript function to be executed when the tree structure 
     * cannot be saved correctly, that is, some error is reported by the server. You
     * can specify an anonymous function like <tt>function() { alert('failed'); }</tt>
     * 
     * @property
     */
    public void setOnError(String onError) {
	this.onError = onError;
    }

    public String getListClass() {
	return this.listClass;
    }

    /**
     * Chooses the html classes to apply to each list.
     * 
     * @property
     */
    public void setListClass(String listClass) {
	this.listClass = listClass;
    }

    public String getListStyle() {
	return this.listStyle;
    }

    /**
     * Chooses the style to apply to each each list.
     * 
     * @property
     */
    public void setListStyle(String listStyle) {
	this.listStyle = listStyle;
    }

    public String getItemClass() {
	return this.itemClass;
    }

    /**
     * The html classes to apply to each list item.
     * 
     * <p>
     * <strong>Note:</strong> if the tree is draggable this class has a special
     * meaning. If you don't specify images for the items this property will be
     * used to determine the image that will be used for the item. Currently only the
     * "folder" and "sheet" classes are supported. So, you you specify the list
     * item class it's also a good idea to override the image for each item.
     * 
     * @see #setImageFor(String, String)
     * 
     * @property
     */
    public void setItemClass(String itemClass) {
	this.itemClass = itemClass;
    }

    public String getItemStyle() {
	return this.itemStyle;
    }

    /**
     * The css style for each list item.
     * 
     * @property
     */
    public void setItemStyle(String itemStyle) {
	this.itemStyle = itemStyle;
    }

    public String getClassesFor(String type) {
	return this.classesMap.get(type);
    }

    /**
     * The css classes to be used in items corresponding to objects of the specified type.
     * 
     * @property
     */
    public void setClassesFor(String type, String method) {
	this.classesMap.put(type, method);
    }

    public String getLinks() {
	return this.links;
    }

    /**
     * Specifies the default link text to be included near each item. The text will be passed 
     * through {@link RenderUtils#getFormattedProperties(String, Object)} with the object of the
     * item. This way you can include references the object's properties in the text.
     * 
     * @property
     */
    public void setLinks(String links) {
	this.links = links;
    }

    public String getHiddenLinks() {
	return hiddenLinks;
    }

    /**
     * This property is similar to the {@link #setLinks(String) links} property but the links
     * defined with this property will be hidden when the tree is draggable. This property is
     * usefull to specify links that simulate the same actions available by drag and drop.
     * 
     * @property
     */
    public void setHiddenLinks(String hiddenlinks) {
	this.hiddenLinks = hiddenlinks;
    }

    public String getLinksFor(String type) {
	return this.linksMap.get(type);
    }

    /**
     * Specifies the links that should appear near items corresponding to objects of the
     * given type. The link text is replaced in the same way than {@link #setLinks(String)}.
     * 
     * @property
     */
    public void setLinksFor(String type, String method) {
	this.linksMap.put(type, method);
    }

    public String getHiddenLinksFor(String type) {
	return this.hiddenLinksMap.get(type);
    }

    /**
     * Specifies the hidden links that should appear near items corresponding to objects of the
     * given type. The link text is replaced in the same way than {@link #setHiddenLinks(String)}.
     * 
     * @property
     */
    public void setHiddenLinksFor(String type, String method) {
	this.hiddenLinksMap.put(type, method);
    }

    public String getLinksClasses() {
	return this.linksClasses;
    }

    /**
     * Chooses the css classes to apply to the container surrounding the item's links.
     * If this property is not set a default class, based on the tree id, is applied. 
     *
     * @property
     */
    public void setLinksClasses(String linksClass) {
	this.linksClasses = linksClass;
    }

    public String getLinksStyle() {
	return this.linksStyle;
    }

    /**
     * Chooses the css style to apply to each item's links.
     * 
     * @property
     */
    public void setLinksStyle(String linksStyle) {
	this.linksStyle = linksStyle;
    }

    public String getMovedClass() {
	return this.movedClass;
    }

    /**
     * Chooses the css class to apply to elements that have been moved.
     * 
     * @property
     */
    public void setMovedClass(String moveClass) {
	this.movedClass = moveClass;
    }

    public String getImage() {
	return image;
    }

    /**
     * Sets the path for the default image to be used for lists items.
     * 
     * @property
     */
    public void setImage(String image) {
	setIncludeImage(false);
	this.image = image;
    }

    public String getImageFor(String type) {
	return this.imagesMap.get(type);
    }

    /**
     * Sets the path of the image that should be used as a icon of items correponding
     * to objects of the given type. The path is context relative. 
     * 
     * @property
     */
    public void setImageFor(String type, String method) {
	setIncludeImage(false);
	this.imagesMap.put(type, method);
    }

    public boolean isIncludeImage() {
	return this.includeImage;
    }

    /**
     * Specifies if the renderer should include the default images when the
     * tree is draggable.
     * 
     * @property
     */
    public void setIncludeImage(boolean includeImage) {
	this.includeImage = includeImage;
    }

    public String getCurrent() {
	return current;
    }

    /**
     * @property
     */
    public void setCurrent(String current) {
	this.current = current;
    }

    public String getCurrentClasses() {
	return currentClasses;
    }

    /**
     * @property
     */
    public void setCurrentClasses(String currentClasses) {
	this.currentClasses = currentClasses;
    }

    public String getCurrentStyle() {
	return currentStyle;
    }

    /**
     * @property
     */
    public void setCurrentStyle(String currentStyle) {
	this.currentStyle = currentStyle;
    }

    @Override
    public Layout getLayout(Object object, Class type) {
	return new TreeLayout();
    }

    public boolean isDraggable() {
	return getTreeId() != null && (getFieldId() != null || getSaveUrl() != null);
    }

    public boolean isExpandable() {
	return this.expandable || isDraggable();
    }

    public void setExpandable(boolean expandable) {
	this.expandable = expandable;
    }

    public LevelDecorator getDecorator() {
	return this.decorator;
    }

    public void setDecorator(LevelDecorator decorator) {
	this.decorator = decorator;
    }

    protected class TreeLayout extends Layout {

	@Override
	public HtmlComponent createComponent(Object object, Class type) {
	    HtmlList list = createList(new ArrayList<HtmlListItem>(), (Collection) object);

	    if (isDraggable()) {
		return createScript(list, true);
	    } else {
		if (isExpandable()) {
		    return createScript(list, false);
		} else {
		    return list;
		}
	    }
	}

	private HtmlComponent createScript(HtmlList list, boolean drag) {
	    String id = getTreeId();

	    if (id == null && !drag) {
		id = "topLevelTree";
	    }

	    list.setId(id);

	    HtmlLink imagesUrlLink = new HtmlLink();
	    imagesUrlLink.setModuleRelative(false);
	    imagesUrlLink.setUrl("/javaScript/drag-drop-folder-tree/images/");

	    HtmlLink requestUrlLink = new HtmlLink();
	    requestUrlLink.setModuleRelative(isModuleRelative());
	    requestUrlLink.setUrl(getSaveUrl());

	    String requestUrl = getSaveUrl() != null ? requestUrlLink.calculateUrl() : null;

	    HtmlScript scriptA = new HtmlScript();
	    scriptA.setContentType("text/javascript");
	    scriptA.setScript(getTreeScript(id, requestUrl, imagesUrlLink.calculateUrl(), drag));

	    HtmlStyle style = new HtmlStyle();
	    style.setStyleBody((getStyle() != null ? String.format("#%s,#%s-container { %s }", id, id, getStyle()) : "") + "\n"
		    + String.format("#%s ul { %s }", id, getListStyle()) + "\n"
		    + String.format("#%s li,#%s-container li { %s }", id, id, getItemStyle()) + "\n");

	    HtmlContainer container = new HtmlBlockContainer();

	    container.addChild(list);
	    container.addChild(style);
	    container.addChild(scriptA);

	    return container;
	}

	private String getTreeScript(String id, String requestUrl, String imagesFolder, boolean drag) {
	    StringBuilder script = new StringBuilder();

	    script.append("treeRenderer_init('" + id + "', {");

	    script.append("imageFolder: '" + imagesFolder + "'");
	    script.append(", includeImage: " + isIncludeImage());

	    if (drag) {
		if (requestUrl != null) {
		    script.append(", requestUrl: '" + requestUrl + "'");
		}

		if (getSaveParameter() != null) {
		    script.append(", requestParameter: '" + getSaveParameter() + "'");
		}

		if (getFieldId() != null) {
		    script.append(", fieldId: '" + getFieldId() + "'");
		}

		if (getOnComplete() != null) {
		    script.append(", onComplete: " + getOnComplete());
		}

		if (getOnError() != null) {
		    script.append(", onError: " + getOnError());
		}

		if (getMovedClass() != null) {
		    script.append(", movedClass: '" + getMovedClass() + "'");
		}
	    } else {
		script.append(", disableDrag: true");
	    }

	    if (getUsableLinksClasses() != null) {
		script.append(", linkClasses: '" + getUsableLinksClasses() + "'");
	    }

	    script.append("});");

	    return script.toString();
	}

	public HtmlList createList(List<HtmlListItem> itemPath, Collection collection) {
	    HtmlList list = new HtmlList();

	    list.setClasses(getListClass());

	    if (collection == null) {
		return list;
	    }

	    for (Object object : collection) {
		if (isIgnored(object)) {
		    continue;
		}

		HtmlListItem item = list.createItem();

		item.setClasses(getClassFor(object));
		item.setStyle(getStyleFor(object));

		HtmlComponent component = generateMainComponent(object);

		String imageUrl = getImageFor(object);
		if (imageUrl != null) {
		    HtmlLink imageLink = new HtmlLink();
		    imageLink.setModuleRelative(false);
		    imageLink.setUrl(imageUrl);

		    HtmlImage image = new HtmlImage();
		    image.setSource(imageLink.calculateUrl());

		    item.addChild(image);
		}

		LevelDecorator decorator = getDecorator();
		if (decorator != null) {
		    HtmlComponent decoratorComponent = decorator.decorate(object);
		    if (decoratorComponent != null) {
			item.addChild(decoratorComponent);
		    }
		}

		item.addChild(component);

		String linksForItem = getLinksFor(object);
		String hiddenLinksForItem = getHiddenLinksFor(object);

		if (linksForItem != null || hiddenLinksForItem != null) {

		    HtmlContainer linksContainer = new HtmlInlineContainer();
		    linksContainer.setClasses(getUsableLinksClasses());
		    linksContainer.setStyle(getLinksStyle());

		    if (hiddenLinksForItem != null) {

			HtmlContainer hiddenContainer = new HtmlInlineContainer();
			hiddenContainer.addChild(new HtmlText(RenderUtils.getFormattedProperties(hiddenLinksForItem, object),
				false));
			linksContainer.addChild(hiddenContainer);
		    }

		    linksContainer.addChild(new HtmlText(RenderUtils.getFormattedProperties(linksForItem, object), false));
		    item.addChild(linksContainer);
		}

		boolean current = false;
		if (getCurrent() != null) {
		    DomainObject domainObject = (DomainObject) object;
		    if (domainObject.getIdInternal().toString().equals(getCurrent())) {
			current = true;

			for (HtmlListItem level : itemPath) {
			    level.setAttribute("expanded", "true");
			}

			component.setClasses(getCurrentClasses());
			component.setStyle(getCurrentStyle());
		    }
		}

		try {
		    String children = getChildrenFor(object);
		    boolean noChildren = getNoChildrenFor(object) != null;

		    if (children != null && !noChildren) {
			Collection subCollection = getChildrenObjects(object, children);

			if (subCollection != null && !subCollection.isEmpty()) {
			    try {
				itemPath.add(item);

				if (current) {
				    item.setAttribute("expanded", "true");
				}

				beforeRecursion(object);
				HtmlList subList = createList(itemPath, subCollection);
				afterRecursion(object);

				if (!subList.getChildren().isEmpty()) {
				    item.addChild(subList);
				}
			    } finally {
				itemPath.remove(item);
			    }
			}
		    } else {
			item.setAttribute("noChildren", "true");
		    }
		} catch (Exception e) {
		    e.printStackTrace();
		}
	    }

	    return list;
	}

	private String getUsableLinksClasses() {
	    if (getLinksClasses() == null) {
		if (getTreeId() != null) {
		    return getTreeId() + "-links";
		} else {
		    return null;
		}
	    } else {
		return getLinksClasses();
	    }
	}

    }

    protected void beforeRecursion(Object object) {
    }

    protected void afterRecursion(Object object) {
    }

    protected HtmlComponent generateMainComponent(Object object) {
	Schema schema = RenderKit.getInstance().findSchema(getSchemaFor(object));
	return renderValue(object, object.getClass(), schema, getLayoutFor(object));
    }

    protected String getChildrenFor(Object object) {
	return getValueFor(object, TreeRenderer.this.childrenMap, getChildren());
    }

    protected String getNoChildrenFor(Object object) {
	return getValueFor(object, TreeRenderer.this.noChildrenMap, null);
    }

    protected String getClassFor(Object object) {
	return getValueFor(object, TreeRenderer.this.classesMap, getItemClass());
    }

    protected String getStyleFor(Object object) {
	return getValueFor(object, TreeRenderer.this.styleMap, null);
    }

    protected String getLinksFor(Object object) {
	return getValueFor(object, TreeRenderer.this.linksMap, getLinks());
    }

    protected String getHiddenLinksFor(Object object) {
	return getValueFor(object, TreeRenderer.this.hiddenLinksMap, getHiddenLinks());
    }

    protected String getImageFor(Object object) {
	return getValueFor(object, TreeRenderer.this.imagesMap, getImage());
    }

    protected String getSchemaFor(Object object) {
	return getValueFor(object, TreeRenderer.this.schemasMap, getEachSchema());
    }

    protected String getLayoutFor(Object object) {
	return getValueFor(object, TreeRenderer.this.layoutsMap, getEachLayout());
    }

    protected String getValueFor(Object object, Map<String, String> map, String defaultValue) {
	String value = null;
	String key = null;

	for (String type : map.keySet()) {
	    if (object.getClass().getName().contains(type)) {
		if (key == null || key.length() < type.length()) {
		    key = type;
		    value = map.get(key);
		}
	    }
	}

	if (value == null) {
	    value = defaultValue;
	}

	return value;
    }

    protected boolean isIgnored(Object object) {
	return false;
    }

    protected Collection getChildrenObjects(Object object, String children) {
	return (Collection) RendererPropertyUtils.getProperty(object, children, false);
    }

    public interface LevelDecorator {
	public HtmlComponent decorate(Object object);
    }

}