/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: Node.java
   * Created: 2007-09-18
   * Author: apohllo
   * $Id: Node.java 2232 2009-01-04 22:59:53Z apohllo $
   */
  
  package pl.edu.agh.cast.model.mapper;
  
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Statement;
  import java.sql.Timestamp;
  import java.sql.Types;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedMap;
  
  /**
   * <p>
   * Metamodel node.
   * </p>
   *
   * <p>
   * Metamodel consists of nodes and links. It allows any upper-level data structure to be stored in the DB, without
   * modifying its scheme or data warehouse interface.
   * </p>
   * <p>
   * Nodes represents any meaningful element of the model, i.e. object or value of the object. Relations between these
   * elements are stored in the <ref>Link</ref> class
   * </p>
   *
   *
   * @author AGH CAST Team
   *
   */
  public class Node {
  
  	private static double delta = 0.000001;
  
  	private static boolean eager = true;
  
  	private List<Link> srcLinks = new ArrayList<Link>();
  
  	private List<Link> dstLinks = new ArrayList<Link>();
  
  	private String typeName;
  
  	private Object value;
  
  	private long id;
  
  	private boolean saved = false;
  
  	private static Mapper mapper = Mapper.getInstance();
  
  	private static Map<Long, Node> nodeCache = Collections.synchronizedMap(new HashMap<Long, Node>());
  
  	/**
  	 * Parameterized constructor.
  	 *
  	 * @param args
  	 *            The map of attributes.
  	 */
  	public Node(Map args) {
  		JRubyIntegration.stringifyKeys(args);
  		initialize((String)args.get("type_name"), null); //$NON-NLS-1$
  	}
  
  	/**
  	 * Parameterized constructor.
  	 *
  	 * @param typeName
  	 *            The name of the type of node.
  	 */
  	public Node(String typeName) {
  		initialize(typeName, null);
  	}
  
  	/**
  	 * Parameterized constructor.
 	 *
 	 * @param typeName
 	 *            The name of the type of the node.
 	 * @param value
 	 *            The value of the node.
 	 */
 	public Node(String typeName, Object value) {
 		initialize(typeName, value);
 	}
 
 	private void initialize(String newTypeName, Object newValue) {
 		typeName = newTypeName;
 		if (newValue != null) {
 			setValue(newValue);
 		}
 	}
 
 	/**
 	 * Type name getter. Returns the type name of the node, i.e. the name of the type which is held by this node. It
 	 * might be FQCN, but doesn't have to - polymorphic mappings are allowed (i.e. node with given type may be mapped to
 	 * different java classes).
 	 *
 	 * @return The name of the type of node.
 	 */
 	public String getTypeName() {
 		return typeName;
 	}
 
 	// ///////////////////////////////////////////////
 	// Values
 	// ///////////////////////////////////////////////
 	/**
 	 * Node value getter.
 	 *
 	 * @return The value of the node
 	 */
 	public Object getValue() {
 		return value;
 	}
 
 	/**
 	 * Node value setter.
 	 *
 	 * @param newValue
 	 *            The value to be set
 	 */
 	public void setValue(Object newValue) {
 		if (newValue == null) {
 			return;
 		}
 		if (!(newValue instanceof Long || newValue instanceof Double || newValue instanceof Integer
 		        || newValue instanceof Boolean || newValue instanceof String || newValue instanceof Date)) {
 			throw new IllegalArgumentException(newValue.getClass().toString());
 		}
 		this.value = newValue;
 	}
 
 	public void setValue(long newValue) {
 		this.value = new Long(newValue);
 	}
 
 	public void setValue(int newValue) {
 		this.value = new Long(newValue);
 	}
 
 	/**
 	 * The value getter.
 	 *
 	 * @return The value of the node.
 	 */
 	public Long getLongValue() {
 		if (value instanceof Long) {
 			return (Long)value;
 		}
 		if (value instanceof Integer) {
 			return new Long((Integer)value);
 		}
 		return null;
 	}
 
 	/**
 	 * The value setter.
 	 *
 	 * @param newValue
 	 *            The value
 	 */
 	public void setValue(double newValue) {
 		this.value = new Double(newValue);
 	}
 
 	/**
 	 * Typed value getter.
 	 *
 	 * @return The value as double.
 	 */
 	public Double getDoubleValue() {
 		if (value instanceof Double) {
 			return (Double)value;
 		}
 		return null;
 	}
 
 	/**
 	 * The value setter.
 	 *
 	 * @param value
 	 *            The value to set.
 	 */
 	public void setValue(boolean value) {
 		this.value = new Boolean(value);
 	}
 
 	/**
 	 * Typed value getter.
 	 *
 	 * @return The value as boolean.
 	 */
 	public Boolean getBooleanValue() {
 		if (value instanceof Boolean) {
 			return (Boolean)value;
 		}
 		return null;
 	}
 
 	/**
 	 * The value setter.
 	 *
 	 * @param value
 	 *            The value as string.
 	 */
 	public void setValue(String value) {
 		this.value = value;
 	}
 
 	/**
 	 * Typed value getter.
 	 *
 	 * @return The value as string.
 	 */
 	public String getStringValue() {
 		if (value instanceof String) {
 			return (String)value;
 		}
 		return null;
 	}
 
 	/**
 	 * The value setter.
 	 *
 	 * @param value
 	 *            The value as date.
 	 */
 	public void setValue(Date value) {
 		this.value = value;
 	}
 
 	/**
 	 * Type value getter.
 	 *
 	 * @return The value as date.
 	 */
 	public Date getDateValue() {
 		if (value instanceof Date) {
 			return (Date)value;
 		}
 		return null;
 	}
 
 	// ///////////////////////////////////////////////
 	// Links
 	// ///////////////////////////////////////////////
 
 	public List<Link> getSrcLinks() {
 		return srcLinks;
 	}
 
 	/**
 	 * The source links setter.
 	 *
 	 * @param links
 	 *            Links to set.
 	 */
 	public void setSrcLinks(Set<Link> links) {
 		srcLinks.clear();
 		srcLinks.addAll(links);
 	}
 
 	/**
 	 * The target links getter.
 	 *
 	 * @return Target links
 	 */
 	public List<Link> getDstLinks() {
 		return dstLinks;
 	}
 
 	/**
 	 * The target links setter.
 	 *
 	 * @param links
 	 *            Links to set
 	 */
 	public void setDstLinks(Set<Link> links) {
 		dstLinks.clear();
 		dstLinks.addAll(links);
 	}
 
 	/**
 	 * Link creator. Links this node with given node.
 	 *
 	 * @param node
 	 *            The node to link.
 	 * @param direction
 	 *            The direction of the link (as seen form "this" node).
 	 * @param name
 	 *            The name of the link.
 	 */
 	public void link(Node node, Object direction, String name) {
 		link(node, translateDirection(direction), name, Priority.NONE);
 	}
 
 	/**
 	 * Links this node with given node.
 	 *
 	 * @param node
 	 *            The node to be linked
 	 * @param direction
 	 *            The direction of the link
 	 * @param name
 	 *            The name of the link
 	 * @param priority
 	 *            The priority of the link
 	 */
 	public void link(Node node, Direction direction, String name, Priority priority) {
 		Link link = new Link(null, null, name, priority);
 		if (direction == Direction.SRC) {
 			link.setSrc(this);
 			link.setDst(node);
 			srcLinks.add(link);
 		} else if (direction == Direction.DST) {
 			link.setDst(this);
 			link.setSrc(node);
 			dstLinks.add(link);
 		} else {
 			throw new IllegalArgumentException("Direction must be specified"); //$NON-NLS-1$
 		}
 		if (saved) {
 			link.save();
 		}
 	}
 
 	/**
 	 * Links accessor.
 	 *
 	 * @param name
 	 *            The name of the links
 	 * @param directionObj
 	 *            The direction of the links
 	 * @return All links which have given name and direction.
 	 */
 	public List<Link> links(String name, Object directionObj) {
 		return links(name, translateDirection(directionObj));
 	}
 
 	/**
 	 * Translates direction object to direction Enum. Return SRC by default.
 	 *
 	 * @param directionObj
 	 *            diretion object
 	 * @return Direction as Enum
 	 */
 	private Direction translateDirection(Object directionObj) {
 		if (directionObj.toString().equals("dst")) {
 			return Direction.DST;
 		}
 		return Direction.SRC;
 	}
 
 	/**
 	 * Returns links with given name.
 	 *
 	 * @param name
 	 *            The name of links
 	 * @return Links matchi given criteria
 	 */
 	public List<Link> links(String name) {
 		return links(name, null);
 	}
 
 	/**
 	 * Find all links with given name, with direction direction. If direction is null, all links with given name are
 	 * returned.
 	 *
 	 * @param name
 	 *            The name of links
 	 * @param direction
 	 *            The direction of links
 	 * @return Links matching given criteria.
 	 */
 	public List<Link> links(String name, Direction direction) {
 		List<Link> sources = new LinkedList<Link>();
 		for (Link link : srcLinks) {
 			if (link.getName().equals(name)) {
 				sources.add(link);
 			}
 		}
 		List<Link> destinations = new LinkedList<Link>();
 		for (Link link : dstLinks) {
 			if (link.getName().equals(name)) {
 				destinations.add(link);
 			}
 		}
 		if (direction == Direction.SRC) {
 			return sources;
 		} else if (direction == Direction.DST) {
 			return destinations;
 		}
 		sources.addAll(destinations);
 		return sources;
 	}
 
 	/**
 	 * Add dependent node. Links this node with given node as its child.
 	 *
 	 * @param node
 	 *            The node to be linked
 	 * @param linkName
 	 *            The name of the link
 	 * @return the created link
 	 */
 	public Link addDependent(Node node, String linkName) {
 		Link link = new Link(node, this, linkName, Priority.DST_OVER_SRC);
 		return link;
 	}
 
 	/**
 	 * String representation of the core data
 	 *
 	 * @return The representation.
 	 */
 	private String typeNameWithValue() {
 		StringBuilder str = new StringBuilder();
 		str.append(typeName);
 		str.append("["); //$NON-NLS-1$
 		str.append(id);
 		if (value != null) {
 			str.append(","); //$NON-NLS-1$
 			str.append(value);
 		}
 		str.append("]\n"); //$NON-NLS-1$
 		return str.toString();
 	}
 
 	/**
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		StringBuilder str = new StringBuilder();
 		str.append(typeNameWithValue());
 		str.append("  > \n"); //$NON-NLS-1$
 		for (Link link : srcLinks) {
 			if (link.getDst() != null) {
 				str.append(link.getDst().typeNameWithValue());
 			}
 		}
 		str.append("  < \n"); //$NON-NLS-1$
 		for (Link link : dstLinks) {
 			if (link.getSrc() != null) {
 				str.append(link.getSrc().typeNameWithValue());
 			}
 		}
 		return str.toString();
 	}
 
 	private static PreparedStatement findByIdStmt;
 
 	private static PreparedStatement findByIdStmtWithLinks;
 
 	private static PreparedStatement findByNameWithZeroLinks;
 
 	private static PreparedStatement findByIdStmtWithZeroLinks;
 
 	private static PreparedStatement findByIdStmtWithAttrs;
 
 	private static PreparedStatement findAttributeByIdStmt;
 
 	private static PreparedStatement findByName;
 
 	private static PreparedStatement findByNameWithLinks;
 
 	private static PreparedStatement insertNodeStmt;
 
 	private static PreparedStatement updateNodeStmt;
 
 	static {
 		String stmtStr;
 		try {
 			stmtStr = "SELECT id, type_name, int_value, float_value, " //$NON-NLS-1$
 			        + "string_value, date_value, boolean_value FROM nodes WHERE id = ?"; //$NON-NLS-1$
 			findByIdStmt = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT n1.id, n1.type_name, null, null, " //$NON-NLS-1$
 			        + "null, null, null, " //$NON-NLS-1$
 			        + "l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 			        + "l1.src_accessor, l1.dst_accessor, l1.src_position, l1.dst_position " //$NON-NLS-1$
 			        + "FROM nodes n1 INNER JOIN links l1 ON (n1.id = l1.src_id OR n1.id = l1.dst_id) " //$NON-NLS-1$
 			        + "WHERE n1.id = ? AND l1.src_accessor IS NOT NULL "; //$NON-NLS-1$
 
 			findByIdStmtWithLinks = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT n1.id, n1.type_name, n1.int_value, n1.float_value, " //$NON-NLS-1$
 			        + "n1.string_value, n1.date_value, n1.boolean_value, " //$NON-NLS-1$
 			        + "l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 			        + "l1.src_accessor, l1.dst_accessor, l1.src_position, l1.dst_position " //$NON-NLS-1$
 			        + "FROM nodes n1 INNER JOIN links l1 ON (n1.id = l1.src_id OR n1.id = l1.dst_id) " //$NON-NLS-1$
 			        + "WHERE n1.id = ? AND l1.src_accessor IS NULL "; //$NON-NLS-1$
 
 			findAttributeByIdStmt = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 			        + "null, null, 0, 0, " //$NON-NLS-1$
 			        + "n2.id, n2.type_name, n2.int_value, n2.float_value, " //$NON-NLS-1$
 			        + "n2.string_value, n2.date_value, n2.boolean_value " //$NON-NLS-1$
 			        + "FROM links l1, nodes n2 " //$NON-NLS-1$
 			        + "WHERE ((l1.src_id = ? AND n2.id = l1.dst_id) OR " //$NON-NLS-1$
 			        + "(l1.dst_id = ? AND n2.id = l1.src_id)) " //$NON-NLS-1$
 			        + "AND l1.src_accessor IS NULL "; //$NON-NLS-1$
 
 			findByIdStmtWithAttrs = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT id, type_name, int_value, float_value, " //$NON-NLS-1$
 			        + "string_value, date_value, boolean_value FROM nodes " //$NON-NLS-1$
 			        + "WHERE type_name = ?"; //$NON-NLS-1$
 			findByName = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT n1.id, n1.type_name, n1.int_value, n1.float_value, " //$NON-NLS-1$
 			        + "n1.string_value, n1.date_value, n1.boolean_value, " //$NON-NLS-1$
 			        + "l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 			        + "l1.src_accessor, l1.dst_accessor, l1.src_position, l1.dst_position, " //$NON-NLS-1$
 			        + "n2.id, n2.type_name, n2.int_value, n2.float_value, " //$NON-NLS-1$
 			        + "n2.string_value, n2.date_value, n2.boolean_value " //$NON-NLS-1$
 			        + "FROM nodes n1, links l1, nodes n2 " //$NON-NLS-1$
 			        + "WHERE ((n1.id = l1.src_id AND n2.id = l1.dst_id) OR " //$NON-NLS-1$
 			        + "(n1.id = l1.dst_id AND n2.id = l1.src_id)) " //$NON-NLS-1$
 			        + "AND n1.type_name = ? ORDER BY n1.id"; //$NON-NLS-1$
 
 			stmtStr = "SELECT n1.id, n1.type_name, null, null, " //$NON-NLS-1$
 			        + "null, null, null, " //$NON-NLS-1$
 			        + "l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 			        + "l1.src_accessor, l1.dst_accessor, l1.src_position, l1.dst_position " //$NON-NLS-1$
 			        + "FROM nodes n1 INNER JOIN links l1 ON (n1.id = l1.src_id OR n1.id = l1.dst_id)" //$NON-NLS-1$
 			        + "WHERE n1.type_name = ? AND l1.src_accessor IS NOT NULL " //$NON-NLS-1$
 			        + "ORDER BY n1.id"; //$NON-NLS-1$
 
 			findByNameWithLinks = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT n1.id, n1.type_name, int_value, float_value, " //$NON-NLS-1$
 			        + "string_value, date_value, boolean_value " //$NON-NLS-1$
 			        + "FROM nodes n1 " //$NON-NLS-1$
 			        + "WHERE n1.type_name = ? " //$NON-NLS-1$
 			        + "ORDER BY n1.id"; //$NON-NLS-1$
 
 			findByNameWithZeroLinks = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "SELECT n1.id, n1.type_name, int_value, float_value, " //$NON-NLS-1$
 			        + "string_value, date_value, boolean_value " //$NON-NLS-1$
 			        + "FROM nodes n1 " //$NON-NLS-1$
 			        + "WHERE n1.id = ? "; //$NON-NLS-1$
 
 			findByIdStmtWithZeroLinks = mapper.getConnection().prepareStatement(stmtStr);
 
 			stmtStr = "INSERT INTO nodes SET type_name = ?, " //$NON-NLS-1$
 			        + "int_value = ?, float_value = ?, string_value = ?, date_value = ?, " //$NON-NLS-1$
 			        + "boolean_value = ? "; //$NON-NLS-1$
 
 			insertNodeStmt = mapper.getConnection().prepareStatement(stmtStr, Statement.RETURN_GENERATED_KEYS);
 
 			stmtStr = "UPDATE nodes SET type_name = ?, " //$NON-NLS-1$
 			        + "int_value = ?, float_value = ?, string_value = ?, date_value = ?, " //$NON-NLS-1$
 			        + "boolean_value = ? WHERE id = ? LIMIT 1"; //$NON-NLS-1$
 
 			updateNodeStmt = mapper.getConnection().prepareStatement(stmtStr, Statement.RETURN_GENERATED_KEYS);
 
 		} catch (SQLException e) {
 			e.printStackTrace();
 		}
 	}
 
 	/**
 	 * Save metamodel node in the DB.
 	 * <p>
 	 * The saving process is recursive. The node is saved first and then all source and destination links are saved.
 	 * </p>
 	 * TODO implement transactions
 	 *
 	 * @return True if the node was saved successfully or it's been saved earlier.
 	 */
 	public boolean save() {
 		if (saved) {
 			return true;
 			// System.out.println("Save node ");
 		}
 
 		// validation
 		if (typeName == null || typeName.equals("")) { //$NON-NLS-1$
 			throw new IllegalArgumentException("Node's type name must not be blank: " + this); //$NON-NLS-1$
 		}
 
 		try {
 			if (id == 0) {
 				// new node
 
 				setValues(insertNodeStmt);
 
 				insertNodeStmt.executeUpdate();
 				ResultSet rs = insertNodeStmt.getGeneratedKeys();
 				if (rs.next()) {
 					setId(rs.getLong(1));
 					setSaved(true);
 				} else {
 					throw new SQLException("Cannot obtain the last node id"); //$NON-NLS-1$
 				}
 
 				// links
 
 				for (Link link : getSrcLinks()) {
 					link.save();
 				}
 				for (Link link : getDstLinks()) {
 					link.save();
 				}
 				// conn.commit();
 				return true;
 			} else {
 				// update
 				setValues(updateNodeStmt);
 				updateNodeStmt.setLong(7, id);
 				updateNodeStmt.executeUpdate();
 				setSaved(true);
 				// TODO update links (?)
 			}
 		} catch (SQLException e) {
 			e.printStackTrace();
 			setSaved(false);
 			// try {
 			// //conn.rollback();
 			// } catch (SQLException e1) {
 			// e1.printStackTrace();
 			// }
 			return false;
 		}
 
 		return false;
 
 	}
 
 	/**
 	 * Returns node with given id or null if not found.
 	 *
 	 * @param nodeId
 	 *            The id of the node
 	 * @return The node or null
 	 */
 	public static Node find(long nodeId) {
 		// System.out.println("Find node "+nodeId);
 		Node node;
 
 		// try cache first
 		// try {
 		node = nodeCache.get(nodeId);
 		if (node != null) {
 			// node.reloadLinks();
 			return node;
 		}
 		// } catch (SQLException e) {
 		// e.printStackTrace();
 		// }
 
 		try {
 			PreparedStatement stmt;
 			if (eager) {
 				stmt = findByIdStmtWithLinks;
 			} else {
 				stmt = findByIdStmt;
 			}
 
 			stmt.setLong(1, nodeId);
 			ResultSet resultSet = stmt.executeQuery();
 
 			if (!resultSet.next()) {
 				if (eager) {
 					findByIdStmtWithZeroLinks.setLong(1, nodeId);
 					resultSet = findByIdStmtWithZeroLinks.executeQuery();
 					if (!resultSet.next()) {
 						throw new RuntimeException("Node with id = " + nodeId //$NON-NLS-1$
 						        + " not found"); //$NON-NLS-1$
 					}
 				} else {
 					throw new RuntimeException("Node with id = " + nodeId //$NON-NLS-1$
 					        + " not found"); //$NON-NLS-1$
 				}
 			}
 
 			node = loadNode(resultSet, eager);
 			return node;
 		} catch (SQLException e) {
 			e.printStackTrace();
 		}
 		return null;
 	}
 
 	/**
 	 * Find all nodes with given type name.
 	 *
 	 * @param typeName
 	 *            The name of the type
 	 * @return Nodes with given type name
 	 */
 	public static List<Node> find(String typeName) {
 		List<Node> nodes = new LinkedList<Node>();
 
 		try {
 			PreparedStatement stmt;
 			if (eager) {
 				stmt = findByNameWithLinks;
 			} else {
 				stmt = findByName;
 			}
 			stmt.setString(1, typeName);
 			ResultSet rs = stmt.executeQuery();
 			if (eager && !rs.next()) {
 				// there might be one node with zero links - try to find it
 				findByNameWithZeroLinks.setString(1, typeName);
 				rs = findByNameWithZeroLinks.executeQuery();
 			} else {
 				rs.previous();
 			}
 			while (rs.next()) {
 				nodes.add(loadNode(rs, eager));
 			}
 			return nodes;
 		} catch (SQLException e) {
 			e.printStackTrace();
 		}
 		return null;
 	}
 
 	/**
 	 * Find all nodes with given type name which satisfy given set of conditions.
 	 *
 	 * @param typeName
 	 *            The name of the type
 	 * @param conditions
 	 *            Map containing pairs: attribute name =&gt; value defining conditions which must be met for model
 	 *            object for metamodel node to be loaded.
 	 * @return Nodes with given type name
 	 */
 
 	public static List<Node> find(String typeName, SortedMap<String, Object> conditions) {
 		List<Node> nodes = new LinkedList<Node>();
 		Statement findWithConditions = null;
 
 		try {
 			// TODO optimization needed?
 			StringBuilder stmtBuilder = new StringBuilder();
 
 			stmtBuilder.append("SELECT n1.id, n1.type_name, n1.int_value, n1.float_value, " //$NON-NLS-1$
 			        + "n1.string_value, n1.date_value, n1.boolean_value "); //$NON-NLS-1$
 			if (eager) {
 				stmtBuilder.append(", l1.id, l1.src_id, l1.dst_id, l1.priority, l1.name, " //$NON-NLS-1$
 				        + "l1.src_accessor, l1.dst_accessor, l1.src_position, l1.dst_position "); //$NON-NLS-1$
 			}
 			stmtBuilder.append("FROM nodes n1 "); //$NON-NLS-1$
 			if (eager) {
 				stmtBuilder.append("INNER JOIN links l1 ON (n1.id = l1.src_id OR n1.id = l1.dst_id) "); //$NON-NLS-1$
 			}
 			stmtBuilder.append("WHERE n1.id IN("); //$NON-NLS-1$
 			subquery(conditions, stmtBuilder);
 			stmtBuilder.append(") AND type_name='"); //$NON-NLS-1$
 			stmtBuilder.append(typeName);
 			stmtBuilder.append("' "); //$NON-NLS-1$
 			if (eager) {
 				stmtBuilder.append("AND l1.src_accessor IS NOT NULL"); //$NON-NLS-1$
 			}
 
 			// System.out.println(stmtStr);
 
 			findWithConditions = mapper.getConnection().createStatement();
 
 			ResultSet rs = findWithConditions.executeQuery(stmtBuilder.toString());
 
 			stmtBuilder.delete(0, stmtBuilder.length() - 1);
 			stmtBuilder = null;
 
 			while (rs.next()) {
 				nodes.add(loadNode(rs, eager));
 			}
 			return nodes;
 		} catch (SQLException e) {
 			e.printStackTrace();
 		} finally {
 			try {
 				if (findWithConditions != null) {
 					findWithConditions.close();
 				}
 			} catch (SQLException e) {
 				e.printStackTrace();
 			}
 		}
 		return null;
 
 	}
 
 	private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm"); //$NON-NLS-1$
 
 	/**
 	 * Returns SQL subquery which allows to select all nodes, which represent model objects whose attribtes have values
 	 * set in the conditions map.
 	 *
 	 * @param conditions
 	 *            The conditions to be met. Destroyed during execution! Pairs: attribute name =&gt; value
 	 * @param stmtBuilder
 	 * @return The string representing SQL subquery
 	 */
 	private static void subquery(SortedMap<String, Object> conditions, StringBuilder stmtBuilder) {
 		String firstKey = conditions.firstKey();
 		Object firstValue = conditions.remove(firstKey);
 
 		stmtBuilder.append("SELECT dst_id FROM links INNER JOIN nodes ON src_id = nodes.id "); //$NON-NLS-1$
 		stmtBuilder.append("WHERE name = '"); //$NON-NLS-1$
 
 		if (!firstKey.startsWith("get")) { //$NON-NLS-1$
 			stmtBuilder.append("get"); //$NON-NLS-1$
 			stmtBuilder.append(firstKey.substring(0, 1).toUpperCase());
 			stmtBuilder.append(firstKey.substring(1));
 		} else {
 			stmtBuilder.append(firstKey);
 		}
 
 		stmtBuilder.append("' AND "); //$NON-NLS-1$
 
 		if ((firstValue instanceof Long) || (firstValue instanceof Integer)) {
 			stmtBuilder.append("int_value = "); //$NON-NLS-1$
 			stmtBuilder.append(firstValue);
 		} else if (firstValue instanceof String) {
 			stmtBuilder.append("string_value = '"); //$NON-NLS-1$
 			stmtBuilder.append(firstValue);
 			stmtBuilder.append("'"); //$NON-NLS-1$
 		} else if (firstValue instanceof Double) {
 			stmtBuilder.append("float_value = "); //$NON-NLS-1$
 			stmtBuilder.append(firstValue);
 		} else if (firstValue instanceof java.util.Date) {
 			stmtBuilder.append("date_value = '"); //$NON-NLS-1$
 			stmtBuilder.append(SIMPLE_DATE_FORMAT.format((java.util.Date)firstValue));
 			stmtBuilder.append("'"); //$NON-NLS-1$
 		} else if (firstValue instanceof Boolean) {
 			if ((Boolean)firstValue) {
 				stmtBuilder.append("boolean_value = 1"); //$NON-NLS-1$
 			} else {
 				stmtBuilder.append("boolean_Value = 0"); //$NON-NLS-1$
 			}
 		} else {
 			throw new RuntimeException("Wrong type of condition value: " //$NON-NLS-1$
 			        + firstValue + " " + firstValue.getClass()); //$NON-NLS-1$
 		}
 
 		if (conditions.size() != 0) {
 			stmtBuilder.append(" AND dst_id IN ("); //$NON-NLS-1$
 			subquery(conditions, stmtBuilder);
 			stmtBuilder.append(")"); //$NON-NLS-1$
 		}
 
 	}
 
 	/**
 	 * Creates node based on the data found in the DB. The node cache is consulted first to ensure referential integrity
 	 * (i.e. nodes with the same id are created only once). TODO cache invalidation (needed?)
 	 *
 	 * The order of data in the result set is as follows:
 	 * <ol>
 	 * <li>id
 	 * <li>type_name
 	 * <li>int_value
 	 * <li>float_value
 	 * <li>string_value
 	 * <li>date_value
 	 * <li>boolean_value
 	 * </ol>
 	 *
 	 *
 	 * @param resultSet
 	 *            The data to be used to create the node
 	 * @param eager
 	 *            links are loaded eagerly - they must be present in the result set, so there is no need to query do DB.
 	 * @return New node initialized with the data stored in the DB.
 	 * @throws SQLException
 	 */
 	private static Node loadNode(ResultSet resultSet, boolean eager) throws SQLException {
 		Node node;
 
 		long nodeId = resultSet.getLong(1);
 		// try node cache first
 		node = nodeCache.get(nodeId);
 		if (node != null) {
 			if (eager) {
 				// since we don't load links, rows with the same nodeId must be
 				// skipped
 				while (resultSet.next()) {
 					if (resultSet.getLong(1) != nodeId) {
 						resultSet.previous();
 						break;
 					}
 				}
 			}
 			return node;
 		}
 
 		node = createNode(resultSet, 0);
 
 		if (eager) {
 			node.loadLinks(resultSet);
 		} else {
 			node.loadSrcLinks();
 			node.loadDstLinks();
 		}
 
 		return node;
 	}
 
 	/**
 	 * Creates node based on current row in given result set. The fields of the node are in strict order (id, type,
 	 * intV, floatV, strV, timeV, booleanV) and starts at offset 'offset'
 	 *
 	 * @param resultSet
 	 *            The result set
 	 * @param offset
 	 *            The offset of node's fields
 	 * @return New node instance
 	 * @throws SQLException
 	 */
 	private static Node createNode(ResultSet resultSet, int offset) throws SQLException {
 		Node node = new Node(resultSet.getString(offset + 2));
 		node.setId(resultSet.getLong(offset + 1));
 		node.setSaved(true);
 
 		node.loadValues((Integer)resultSet.getObject(offset + 3), (Float)resultSet.getObject(offset + 4),
 		        (String)resultSet.getObject(offset + 5), (Timestamp)resultSet.getObject(offset + 6), (Boolean)resultSet
 		                .getObject(offset + 7));
 
 		nodeCache.put(node.getId(), node);
 		return node;
 	}
 
 	/**
 	 * Load value of the node. The value of the first non-null attribute is used.
 	 *
 	 * @param iValue
 	 * @param fValue
 	 * @param sValue
 	 * @param ttValue
 	 * @param bValue
 	 */
 	private void loadValues(Integer iValue, Float fValue, String sValue, Timestamp ttValue, Boolean bValue) {
 		// mysql uses Integer
 		Long lValue = null;
 		if (iValue != null) {
 			lValue = new Long(iValue);
 		}
 
 		// mysql uses Float
 		Double ddValue = null;
 		if (fValue != null) {
 			ddValue = new Double(fValue);
 		}
 
 		// mysql uses Timestamp
 		java.util.Date dValue = null;
 		if (ttValue != null) {
 			dValue = new java.util.Date(ttValue.getTime());
 		}
 
 		// max one value != null
 		if (lValue != null) {
 			setValue(lValue);
 		} else if (fValue != null) {
 			setValue(ddValue);
 		} else if (sValue != null) {
 			setValue(sValue);
 		} else if (dValue != null) {
 			setValue(dValue);
 		} else if (bValue != null) {
 			setValue(bValue);
 		}
 	}
 
 	/**
 	 * Load source links.
 	 *
 	 * @throws SQLException
 	 */
 	private void loadSrcLinks() throws SQLException {
 		List<Link> links = Link.findWithSrc(id);
 		for (Link link : links) {
 			addSrcLink(link);
 		}
 	}
 
 	/**
 	 * Load destination links.
 	 *
 	 * @throws SQLException
 	 */
 	private void loadDstLinks() throws SQLException {
 		List<Link> links = Link.findWithDst(id);
 		for (Link link : links) {
 			addDstLink(link);
 		}
 	}
 
 	/**
 	 * Eagerly load links (they are present in the result set, so there is no need to query the DB).
 	 *
 	 * @param resultSet
 	 * @throws SQLException
 	 */
 	private void loadLinks(ResultSet resultSet) throws SQLException {
 		// result set contains only links with nodes which are not attributes
 		// i.e. their src_accessor and dst_accessor is not null
 		resultSet.previous();
 		while (resultSet.next()) {
 			long nodeId = resultSet.getLong(1);
 			if (nodeId != this.id) {
 				resultSet.previous();
 				break;
 			}
 			if (resultSet.getMetaData().getColumnCount() > 7) {
 				Link link = Link.createLink(resultSet, 7);
 				if (link.getSrcId() == this.id) {
 					link.setSrc(this);
 				} else {
 					link.setDst(this);
 				}
 				addLink(link);
 			}
 		}
 
 		// load the other link with corresponding values
 		findByIdStmtWithAttrs.setLong(1, this.id);
 		findByIdStmtWithAttrs.setLong(2, this.id);
 		resultSet = findByIdStmtWithAttrs.executeQuery();
 		while (resultSet.next()) {
 			Link link = Link.createLink(resultSet, 0);
 			Node node = createNode(resultSet, 9);
 			if (link.getSrcId() == this.id) {
 				link.setSrc(this);
 				addSrcLink(link);
 				link.setDst(node);
 				node.addDstLink(link);
 			} else {
 				link.setDst(this);
 				addDstLink(link);
 				link.setSrc(node);
 				node.addSrcLink(link);
 			}
 		}
 	}
 
 	/**
 	 * Reloads links of given node from DB.
 	 *
 	 * @throws SQLException
 	 */
 	public void reloadLinks() throws SQLException {
 		srcLinks.clear();
 		dstLinks.clear();
 		loadSrcLinks();
 		loadDstLinks();
 	}
 
 	/**
 	 * Finds metamodel node for given model object.
 	 *
 	 * @param object
 	 *            The object for which the node is found
 	 * @return Metamodel node representing object.
 	 */
 	public static Node find(Mappable object) {
 		return Node.find(object.getMid());
 	}
 
 	/**
 	 * Set node values in the update statement. The order of values in the statement is as follows
 	 * <ol>
 	 * <li>type_name
 	 * <li>int_value
 	 * <li>float_value
 	 * <li>string_value
 	 * <li>date_value
 	 * <li>boolean_value
 	 * </ol>
 	 *
 	 * @param stmt
 	 *            The statement used for update
 	 * @param node
 	 *            Node
 	 * @throws SQLException
 	 */
 	private void setValues(PreparedStatement stmt) throws SQLException {
 		stmt.setString(1, getTypeName());
 		// long
 		Long lValue = getLongValue();
 		if (lValue != null) {
 			stmt.setLong(2, lValue);
 		} else {
 			stmt.setNull(2, Types.BIGINT);
 		}
 
 		// double
 		Double dValue = getDoubleValue();
 		if (dValue != null) {
 			stmt.setDouble(3, dValue);
 		} else {
 			stmt.setNull(3, Types.DOUBLE);
 		}
 
 		// string
 		String sValue = getStringValue();
 		if (sValue != null) {
 			stmt.setString(4, sValue);
 		} else {
 			stmt.setNull(4, Types.VARCHAR);
 		}
 
 		// date
 		java.util.Date date = getDateValue();
 		if (date != null) {
 			stmt.setTimestamp(5, new Timestamp(date.getTime()));
 		} else {
 			stmt.setNull(5, Types.DOUBLE);
 		}
 
 		// boolean
 		Boolean bValue = getBooleanValue();
 		if (bValue != null) {
 			stmt.setBoolean(6, bValue);
 		} else {
 			stmt.setNull(6, Types.BOOLEAN);
 		}
 	}
 
 	/**
 	 * Saved flag setter.
 	 *
 	 * @param saved
 	 *            The saved flag
 	 */
 	public void setSaved(boolean saved) {
 		this.saved = saved;
 	}
 
 	/**
 	 * Find node which is the same as the given node in terms of their id.
 	 *
 	 * @param node
 	 *            The node to find.
 	 * @return The node with the same id.
 	 */
 	public static Node find(Node node) {
 		return find(node.getId());
 	}
 
 	/**
 	 * Finds all nodes with given type name.
 	 *
 	 * @param typeName
 	 *            The type name of the node.
 	 * @return The list of nodes.
 	 */
 	public static List<Node> findAllByTypeName(String typeName) {
 		return Node.find(typeName);
 	}
 
 	/**
 	 * DB identifier getter.
 	 *
 	 * @return DB identifier
 	 */
 	public long getId() {
 		return id;
 	}
 
 	/**
 	 * DB identifier setter - only default access.
 	 *
 	 * @param nodeId
 	 */
 	void setId(long nodeId) {
 		id = nodeId;
 	}
 
 	/**
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object other) {
 		if (this == other) {
 			return true;
 		}
 
 		if (!(other instanceof Node)) {
 			return false;
 		}
 		Node that = (Node)other;
 
 		// value may be null
 		if (this.value == null) {
 			if (that.value != null) {
 				return false;
 			}
 		} else {
 			if (this.value instanceof Double && that.value instanceof Double) {
 				Double d1 = (Double)this.value;
 				Double d2 = (Double)that.value;
 				if (Math.abs(d1 - d2) > delta) {
 					return false;
 				}
 			} else {
 				if (!this.value.equals(that.value)) {
 					return false;
 				}
 			}
 		}
 
 		return this.typeName.equals(that.typeName) && this.srcLinks.equals(that.srcLinks)
 		        && this.dstLinks.equals(that.dstLinks) && this.id == that.id;
 		// TODO if id == 0 two nodes are equal only if their object_id is the
 		// same (?)
 		// rather the other way around!
 	}
 
 	/**
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see java.lang.Object#hashCode()
 	 */
 	@Override
 	public int hashCode() {
 		int result = (int)(typeName.hashCode() ^ (srcLinks.hashCode() * 3) ^ (dstLinks.hashCode() * 5) ^ (id * 11));
 		if (value != null) {
 			result ^= value.hashCode() * 13;
 		}
 		return result;
 	}
 
 	/**
 	 * Add source link.
 	 *
 	 * @param link
 	 *            Link to add
 	 */
 	public void addSrcLink(Link link) {
 		srcLinks.add(link);
 	}
 
 	/**
 	 * Add destination link.
 	 *
 	 * @param link
 	 *            Link to add
 	 */
 	public void addDstLink(Link link) {
 		dstLinks.add(link);
 	}
 
 	/**
 	 * Add link to this node. The src/dstPosition and src/dstId are considered when the link is added.
 	 *
 	 * The link is added as srcLink if the srcId of the link is the same as the id of this node and as dstLink if the
 	 * dstId of the link is the same as the id of this node. Otherwise IllegalArgumentException is thrown.
 	 *
 	 * The position of the link in the list (say _srcLinks) is preserved according to its position attribute (in case of
 	 * _srcLinks - dstPostion !! value). This might not equal the actual position in the links list, especially during
 	 * the reconstruction of the node.
 	 *
 	 * @param link
 	 *            Link to add
 	 */
 	public void addLink(Link link) {
 		if (link.getSrcId() == this.id) {
 			// TODO optimization needed?
 			for (Link cLink : srcLinks) {
 				if (cLink.getDstPosition() >= link.getDstPosition()) {
 					srcLinks.add(srcLinks.indexOf(cLink), link);
 					return;
 				}
 			}
 			srcLinks.add(link);
 		} else if (link.getDstId() == this.id) {
 			// TODO optimization needed?
 			for (Link cLink : dstLinks) {
 				if (cLink.getSrcPosition() >= link.getSrcPosition()) {
 					dstLinks.add(dstLinks.indexOf(cLink), link);
 					return;
 				}
 			}
 			dstLinks.add(link);
 		} else {
 			throw new IllegalArgumentException("The source or destination of the link " + //$NON-NLS-1$
 			        "must equal to this node id [" + this.id + "]"); //$NON-NLS-1$ //$NON-NLS-2$
 		}
 	}
 
 	/**
 	 * Prints the cache status.
 	 */
 	public static void stats() {
 		// TODO DO NOT USE PRINTLN
 		// System.out.println("Node cache " + _nodeCache.size()); //$NON-NLS-1$
 	}
 
 	static void clearCache() {
 		nodeCache.clear();
 	}
 }