/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * 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:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.scenegraph.g2d.nodes;

import java.awt.AlphaComposite;
import java.awt.Composite;
import java.awt.Graphics2D;

import org.simantics.scenegraph.g2d.IG2DNode;
import org.simantics.scenegraph.utils.InitValueSupport;

public class SingleElementNode extends TransformNode implements InitValueSupport {
    /**
     * 
     */
    private static final long serialVersionUID = -4982578347433716440L;

    protected Composite composite;
    protected Boolean visible = Boolean.TRUE;
    protected Boolean hidden = Boolean.FALSE;

    @Override
    public boolean validate() {
        return visible && !hidden;
    }

    @SyncField("composite")
    public void setComposite(Composite composite) {
        this.composite = composite;
    }

    @SyncField("visible")
    public void setVisible(Boolean visible) {
        this.visible = visible;
    }

    public boolean isVisible() {
        return visible;
    }

    @SyncField("hidden")
    public void setHidden(Boolean hidden) {
        this.hidden = hidden;
    }

    public boolean isHidden() {
        return hidden;
    }

    @Override
    public void render(Graphics2D g) {
        if (!visible || hidden)
            return;

        Composite oldComposite = null;
        if(composite != null) {
            oldComposite = g.getComposite();
            g.setComposite(composite);
        }
        if(alphaComposite != null) {
            if (oldComposite == null)
                oldComposite = g.getComposite();
            g.setComposite(alphaComposite);
        }

        super.render(g);

        if (oldComposite != null)
            g.setComposite(oldComposite);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append(" [");
        if (composite != null) {
            sb.append("composite=(");
            AlphaComposite ac = (AlphaComposite) composite;
            sb.append(ac.getRule());
            sb.append(", ");
            sb.append(ac.getAlpha());
            sb.append("), ");
        }
        sb.append("visible=");
        sb.append(visible);
        sb.append("]");
        return sb.toString();
    }

//    private INode findChild(String key) {
//
//    	INode result = getNode(key);
//    	if(result != null) return result;
//
//    	for(Map.Entry<String, IG2DNode> entry : children.entrySet()) {
//
//    		if(!(entry.getValue() instanceof SingleElementNode)) {
//    			if(entry.getKey().startsWith(key)) return entry.getValue();
//    		}
//
//    	}
//
//    	for(IG2DNode node : getNodes()) {
//
//    		if(node instanceof SingleElementNode) {
//
//    			result = ((SingleElementNode)node).findChild(key);
//    			if(result != null) return result;
//
//    		}
//
//    	}
//
//    	return null;
//
//    }

    protected Composite alphaComposite = null;

    @PropertySetter("alpha")
    @SyncField("alphaComposite")
    public void setAlphaComposite(Composite alphaComposite) {
        this.alphaComposite = alphaComposite;
    }

//    public void setValue(String key, Object value) {
//
//        if ("alpha".equals(key)) {
//        	Float val = Float.parseFloat((String)value);
//        	alphaComposite = AlphaComposite.getInstance(AlphaComposite. SRC_OVER, val);
//        } else {
//
//        	String[] parts = key.split("\\.");
//        	if(parts.length != 2) return;
//
//        	INode child = findChild(parts[0]);
//
//        	if(child == null) return;
//
////        	child.setValue(parts[1], value);
//
//        }
//
//    }

    @Override
    public void initValues() {
        alphaComposite = null;
        for (IG2DNode node : getSortedNodes()) {
            if (node instanceof InitValueSupport) {
                ((InitValueSupport) node).initValues();
            }
        }
    }

}