/*
    * 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: DBSaver.java
   * Created: 2008-01-04
   * Author: apohllo
   * $Id: DBSaver.java 2232 2009-01-04 22:59:53Z apohllo $
   */
  
  package pl.edu.agh.cast.model.mapper.internal;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.lang.reflect.Type;
  import java.sql.SQLException;
  import java.util.List;
  
  import pl.edu.agh.cast.model.mapper.AttributeSaver;
  import pl.edu.agh.cast.model.mapper.Direction;
  import pl.edu.agh.cast.model.mapper.Link;
  import pl.edu.agh.cast.model.mapper.Mappable;
  import pl.edu.agh.cast.model.mapper.Mapper;
  import pl.edu.agh.cast.model.mapper.Node;
  import pl.edu.agh.cast.model.mapper.Priority;
  import pl.edu.agh.cast.model.mapper.annotation.MapLink;
  import pl.edu.agh.cast.model.mapper.annotation.Mapping;
  
  /**
   * The saver implementation which uses relational data base to store objects.
   *
   * @author AGH CAST Team
   *
   */
  public class DBSaver extends AbstractSaver {
  
  	/**
  	 * The parameterized constructor.
  	 *
  	 * @param object
  	 *            The object to save.
  	 * @param force
  	 *            Flag indicating that given object should be saved, no matter if it was saved earlier.
  	 */
  	public DBSaver(Mappable object, boolean force) {
  		super(object, force);
  	}
  
  	/**
  	 *
  	 * {@inheritDoc}
  	 *
  	 * @see pl.edu.agh.cast.model.mapper.Saver#save()
  	 */
  	public boolean save() {
  		if (!Mapper.isDBPresent()) {
  			log.warn("DB is not initialized"); //$NON-NLS-1$
  			return false;
  		}
  		try {
  			queue.addLast(primaryObject);
  			visited.add(primaryObject);
  			while (!queue.isEmpty()) {
  				Mappable element = queue.removeFirst();
  				Node node = internalSave(element);
  				Class klass = element.getClass();
  				saveLinks(element, node, klass);
  				stored.add(element);
  			}
  
  			return true;
  		} catch (Exception e) {
  			e.printStackTrace();
  			return false;
  		}
  	}
  
  	private Node internalSave(Mappable object) throws Exception {
  		Class<Mappable> klass = (Class<Mappable>)object.getClass();
  		if (klass.isAnnotationPresent(Mapping.class)) {
  			Node node;
  			long id = object.getMid();
  			if (id == 0) {
  				node = new Node(Helper.mappedTypeName(klass));
  				if (!node.save()) {
  					throw new RuntimeException("Node for object " + object //$NON-NLS-1$
  					        + " not saved."); //$NON-NLS-1$
  				}
  				object.setMid(node.getId());
  				nodes.put(node.getId(), node);
  			} else {
  				node = nodes.get(id);
 				if (node == null) {
 					node = Node.find(id);
 				}
 			}
 			saveAttributes(object, node, object.getClass());
 			return node;
 		} else {
 			throw new IllegalArgumentException("Object " + object //$NON-NLS-1$
 			        + " not mapped."); //$NON-NLS-1$
 		}
 	}
 
 	/**
 	 * Save links and objects linked to given object.
 	 *
 	 * @param object
 	 *            The object whose links are saved
 	 * @param node
 	 *            The metamodel node of the saved object
 	 * @throws Exception
 	 *
 	 */
 	private void saveLinks(Mappable object, Node node, Class<Mappable> klass) throws Exception {
 		if (Helper.isSuperMapped(klass)) {
 			saveLinks(object, node, (Class<Mappable>)klass.getSuperclass());
 			// TODO DO NOT USE PRINTLN
 			// System.out.println("Saving... " + klass.getSimpleName() +" " +
 			// object);
 		}
 
 		// TODO custom save !!
 		for (LinkEntry entry : Helper.getMappedLinks(klass)) {
 			Object linkedItem = entry.getMethod().invoke(object);
 			int position = 0;
 			if (linkedItem instanceof List) {
 				List<Mappable> items = (List<Mappable>)linkedItem;
 				for (Mappable item : items) {
 					createLink(entry.getAnnotation(), object, item, node, position);
 					position++;
 				}
 			} else {
 				createLink(entry.getAnnotation(), object, (Mappable)linkedItem, node, position);
 			}
 		}
 	}
 
 	/**
 	 * Create metamodel link between metamodel node representing given item and another node given as argument
 	 * (representing object which is linked with the item)
 	 *
 	 * @param linkMapping
 	 *            Metamodel data concerning the created link
 	 * @param thatItem
 	 *            The item whos node is linked
 	 * @param thisNode
 	 *            The other node for which the node is created
 	 * @throws SQLException
 	 * @throws Exception
 	 */
 	private void createLink(MapLink linkMapping, Mappable thisItem, Mappable thatItem, Node thisNode, int dstPosition)
 	        throws Exception {
 		if (!visited.contains(thatItem)) {
 			queue.addLast(thatItem);
 			visited.add(thatItem);
 		}
 
 		if (stored.contains(thatItem)) {
 			// the link is already created
 			return;
 		}
 
 		// System.out.println("creatLink "+thatItem);
 		Node thatNode = internalSave(thatItem);
 		String linkName = linkMapping.name();
 
 		// pick the position of self on the other side of the link
 		Method method = Helper.getAnnotatedMethod(thatItem.getClass(), linkName);
 		int srcPosition = 0;
 		Type klass2 = method.getReturnType();
 		if (klass2 != null && klass2.equals(List.class)) {
 			Method setter = thatItem.getClass().getMethod(method.getName());
 			List elements = (List)setter.invoke(thatItem, new Object[] {});
 			for (Object element : elements) {
 				if (element.equals(thisItem)) {
 					break;
 				}
 				srcPosition++;
 			}
 		}
 
 		// create new link between metamodel nodes
 		Link link;
 		if (linkMapping.direction() == Direction.DST) {
 			// thisNode is the dst node
 			// thatNode is the src node
 			link = new Link(thatNode, thisNode, linkName, Priority.NONE, Helper.objectAccessor(thatItem.getClass(),
 			        linkName), Helper.objectAccessor(thisItem.getClass(), linkName), dstPosition, srcPosition);
 		} else {
 			// thisNode is the src node
 			// thatNode node is the dst node
 			link = new Link(thisNode, thatNode, linkName, Priority.NONE, Helper.objectAccessor(thisItem.getClass(),
 			        linkName), Helper.objectAccessor(thatItem.getClass(), linkName), srcPosition, dstPosition);
 		}
 		// TODO if the link was saved earlier (in previous save session)
 		// it won't be saved due to SQLConstrainError. Find better way
 		// of solving this problem.
 		link.save();
 	}
 
 	/**
 	 * Save attributes of given object by converting them to metamodel nodes.
 	 *
 	 * @param object
 	 *            The object whose attributes are saved.
 	 * @param node
 	 *            The metamodel node of the saved object
 	 * @throws Exception
 	 */
 	private void saveAttributes(Mappable object, Node node, Class klass) throws Exception {
 		if (Helper.isSuperMapped(klass)) {
 			saveAttributes(object, node, klass.getSuperclass());
 		}
 		// System.out.println("Saving attributes... " + klass.getSimpleName() +"
 		// " +
 		// object);
 		for (AttributeEntry entry : Helper.getMappedAttributes(klass)) {
 			Object value = entry.getMethod().invoke(object);
 			String attributeName = entry.getAnnotation().name();
 			if (attributeName.equals("")) { //$NON-NLS-1$
 				attributeName = entry.getMethod().getName();
 			}
 			List<Link> links = node.links(attributeName);
 			if (entry.getAnnotation().save().equals(Object.class)) {
 				// default implementation
 				Node attributeNode;
 				if (links.size() == 0) {
 					// attribute node doesn't exist - create it!
 					attributeNode = new Node(entry.getAnnotation().typeName(), value);
 					Link link = node.addDependent(attributeNode, attributeName);
 					attributeNode.save();
 					link.save();
 				} else {
 					// update attribute node
 					if (links.size() != 1) {
 						throw new RuntimeException("Too many links for attribute " + attributeName //$NON-NLS-1$
 						        + " for " + klass + "[" + node.getId() //$NON-NLS-1$ //$NON-NLS-2$
 						        + "]"); //$NON-NLS-1$
 					} else {
 						attributeNode = links.get(0).getSrc();
 						attributeNode.setValue(value);
 						attributeNode.save();
 					}
 				}
 			} else {
 				Constructor cons = entry.getAnnotation().save().getConstructor(new Class[] { klass });
 				AttributeSaver saver = (AttributeSaver)cons.newInstance(new Object[] { object });
 				saver.saveAttribute(node, links);
 			}
 		}
 	}
 }