/*******************************************************************************
 * Copyright (c) 2012, 2013 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.g3d.scenegraph.structural;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.simantics.g3d.ontology.G3D;
import org.simantics.g3d.property.annotations.GetPropertyValue;
import org.simantics.g3d.property.annotations.SetPropertyValue;
import org.simantics.g3d.scenegraph.base.Node;
import org.simantics.layer0.Layer0;
import org.simantics.objmap.graph.annotations.RelatedGetValue;
import org.simantics.objmap.graph.annotations.RelatedSetValue;
import org.simantics.objmap.structural.IStructuralObject;
import org.simantics.utils.datastructures.MapList;

public abstract class ComponentNode<T extends Connection, T2 extends IComponentNode> extends Node implements IComponentNode<T, T2>{

	
	private String name;
	

	@RelatedGetValue(Layer0.URIs.HasName)
	@GetPropertyValue(value = Layer0.URIs.HasName, tabId = "Default", name = "Name")
	public String getName() {
		return name;
	}
	
	@RelatedSetValue(Layer0.URIs.HasName)
	@SetPropertyValue(Layer0.URIs.HasName)
	public void setName(String name) {
		if (name == null)
			return;
		this.name = name;
		firePropertyChanged(Layer0.URIs.HasName);
	}
	
	@Override
	public String toString() {
		return getName();
	}
	
	public boolean isPartOfInstantiatedModel() {
		return ctx.size() > 0;
	}
	
	public boolean isExposed() {
		if (ctx.size() == 0)
			return true;
		return getPublishedBy().contains(ctx.get(0));
	}
	
	@Override
	public boolean isInstantiatedModelRoot() {
		return ctx.size() == 1 && this.equals(ctx.get(0));
	}
	
	@Override
	public boolean isPublishable() {
		return !isPartOfInstantiatedModel();
	}
	
	private List<IStructuralObject> ctx = new ArrayList<IStructuralObject>(1);
	@Override
	public List<IStructuralObject> getContext() {
		return ctx;
	}
	
	@Override
	public void setContext(List<IStructuralObject> object) {
		ctx = object;
	}
	
	private List<IStructuralNode> publisher = new ArrayList<IStructuralNode>(1);
	
	
	
	protected abstract boolean isValidConnectionId(String id);
	
	@Override
	public void connectionChanged(T c, T2 node, boolean add) {
		
	}
	
	@Override
	public void addPublishedBy(IStructuralNode node) {
		publisher.add(node);
		firePropertyChanged(G3D.URIs.publishes);
	}
	
	@Override
	public Collection<IStructuralNode> getPublishedBy() {
		return publisher;
	}
	
	@Override
	public void removePublishedBy(IStructuralNode node) {
		if (publisher.remove(node))
			firePropertyChanged(G3D.URIs.publishes);
	}
	
	
	@Override
	public List<T> getConnections(String id) {
		List<T> list = new ArrayList<T>();
		list.addAll(connections.getValues(id));
		list.addAll(connections.getValues(id+"/str"));
		return list;
	}	
	
	public List<T2> getAllConnectedNodes() {
		List<T2> list = new ArrayList<T2>();
		for (T c : getAllConnections()) {
			T2 node = (T2)c.getOther(this);
			if (node != null)
				list.add(node);
		}
		return list;
	}
	
	
	@Override
	public void addConnection(String id, T c) {
		assert(isValidConnectionId(id));
		if (!isPartOfInstantiatedModel())
			_addConnection(id, c);
		else
			_addConnection(id+"/str", c);
	}
	
	@Override
	public void removeConnection(String id, T c) {
		assert(isValidConnectionId(id));
		if (!isPartOfInstantiatedModel())
			_removeConnection(id, c);
		else
			_removeConnection(id+"/str", c);
	}
	
	@Override
	public void removeConnection(String id) {
		assert(isValidConnectionId(id));
		if (!isPartOfInstantiatedModel())
			_removeConnection(id);
		else
			_removeConnection(id+"/str");
	}
	
	private MapList<String, T> connections = new MapList<String, T>();
	
	
	protected void _addConnection(String id, T c) {
		connections.add(id, c);
		c.addConnect(this);
		firePropertyChanged(id);
	}
	
	protected void _addStrConnection(String id, T c) {
		_addConnection(id+"/str", c);
	}
	
	protected  MapList<String, T> _getConnections() {
		return connections;
	}
	
	protected  List<T> _getConnections(String id) {
		return connections.getValues(id);
	}
	
	protected  List<T> _getStrConnections(String id) {
		return _getConnections(id+"/str");
	}
	
	protected void _removeConnection(String id, T c) {
		if (connections.remove(id, c)) {
			c.remove();
			firePropertyChanged(id);
		}
	}
	
	protected void _removeConnection(String id) {
		List<T> conns = new ArrayList<T>();
		conns.addAll(_getConnections(id));
		for (T c : conns) {
			_removeConnection(id, c);
		}
	}
	
	protected void _removeStrConnection(String id, T c) {
		_removeConnection(id+"/str", c);
	}
	
	public List<T> getAllConnections() {
		List<T> list = new ArrayList<T>();
		List<String> keys = new ArrayList<String>();
		keys.addAll(connections.getKeys());
		Collections.sort(keys);
		for (String s : keys)
			list.addAll(connections.getValues(s));
		return list;
	}
	
	public void removeConnection(T c) {
		String keys[] = connections.getKeys(new String[connections.getKeySize()]);
		for (String s : keys) {
			if (connections.contains(s, c))
				_removeConnection(s, c);
		}
	}
	
	public List<T2> getConnectedNodes(String id) {
		List<T2> list = new ArrayList<T2>();
		for (T c : getConnections(id)) {
			T2 node = (T2)c.getOther(this);
			if (node != null)
				list.add(node);
		}
		return list;
	}
	
	@Override
	public String getConnectionId(T c) {
		for (String s : connections.getKeys()) {
			if (connections.contains(s, c)) {
				if (!s.endsWith("/str"))
					return s;
				return s.substring(0, s.length()-4);
			}
		}
		return null;
	}
	
	@Override
	public Collection<String> getConnectionIds(T2 node) {
		Collection<String> ids = new ArrayList<String>();
		for (String s : connections.getKeys()) {
			for (T c : connections.getValues(s)) {
				if (node.equals(c.getOther(this))) {
					if (!s.endsWith("/str"))
						ids.add(s);
					else
						ids.add(s.substring(0, s.length()-4));
				}
			}
		}
		return ids;
	}
	
	@Override
	public void remove() {
		List<T> connections = getAllConnections();
		for (T c : connections) {
			removeConnection(c);
		}
		super.remove();
	
	}
}