/*
    * 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: DBLoader.java
   * Created: 2007-01-04
   * Author: apohllo
   * $Id: DBLoader.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.util.Collections;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.SortedMap;
  
  import pl.edu.agh.cast.model.mapper.AttributeLoader;
  import pl.edu.agh.cast.model.mapper.Direction;
  import pl.edu.agh.cast.model.mapper.Link;
  import pl.edu.agh.cast.model.mapper.LinkLoader;
  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.annotation.MapAttribute;
  import pl.edu.agh.cast.model.mapper.annotation.MapLink;
  import pl.edu.agh.cast.model.mapper.annotation.Mapping;
  
  /**
   * The loader which uses relational data base to store objects.
   *
   * @author AGH CAST Team
   *
   */
  public class DBLoader extends AbstractLoader {
  
  	/**
       *
       */
  	private static final String SET_PREFIX = "set";
  
  	/**
  	 * The parameterized constructor.
  	 *
  	 * @param objectCache
  	 *            The object cache used for referential integrity.
  	 * @param klass
  	 *            The class of the object to load
  	 * @param typeMap2
  	 *            The type map
  	 * @param conditions
  	 *            The conditions the object must satisfy to be loaded.
  	 */
  	public DBLoader(Map<Node, Mappable> objectCache, Class<Mappable> klass, Map<String, Class> typeMap2,
  	        SortedMap<String, Object> conditions) {
  		super(objectCache, klass, typeMap2, conditions);
  	}
  
  	/**
  	 *
  	 * {@inheritDoc}
  	 *
  	 * @see pl.edu.agh.cast.model.mapper.Loader#find()
  	 */
  	public List<Mappable> find() {
  		if (!Mapper.isDBPresent()) {
  			log.warn("DB is not initialized"); //$NON-NLS-1$
  			return new LinkedList<Mappable>();
  		}
  
  		Mapping mapping = klass.getAnnotation(Mapping.class);
  		if (mapping == null) {
  			throw new IllegalArgumentException("Class " + klass //$NON-NLS-1$
  			        + " is not mapped to metamodel"); //$NON-NLS-1$
  		}
  		if (typeMap == null) {
  			typeMap = new HashMap<String, Class>();
  		}
  		String typeName = Helper.mappedTypeName(klass);
  		if (typeMap.get(typeName) == null) {
  			typeMap.put(typeName, klass);
  		}
  		try {
  			List<Node> nodes = null;
  			if (conditions == null) {
  				nodes = Node.find(typeName);
  			} else {
 				nodes = Node.find(typeName, conditions);
 			}
 			List<Mappable> result = new LinkedList<Mappable>();
 
 			for (Node node : nodes) {
 				result.add(load(node));
 			}
 			return result;
 		} catch (Exception ex) {
 			ex.printStackTrace();
 		}
 		return Collections.emptyList();
 	}
 
 	/**
 	 * Load model object mapped to the node passed as the argument. The loading process is recursive.
 	 *
 	 * @param node
 	 *            The metamodel node
 	 * @return Model object
 	 * @throws Exception
 	 */
 	private Mappable load(Node node) throws Exception {
 		Mappable cached = objectCache.get(node);
 		Class<Mappable> klass = Helper.mappedClass(node.getTypeName(), typeMap);
 
 		if (cached != null && cached.getClass().equals(klass)) {
 			return cached;
 		}
 
 		Constructor<Mappable> constructor = Helper.getConstructor(klass);
 		Mappable newInstance = constructor.newInstance((Object[])null);
 		newInstance.setMid(node.getId());
 		objectCache.put(node, newInstance);
 		loadAttributes(node, newInstance, klass);
 		loadLinks(node, newInstance, klass);
 		return newInstance;
 	}
 
 	/**
 	 * Load links of given node
 	 *
 	 * @param node
 	 *            Node whos attributes are loaded
 	 * @param object
 	 *            The object which owns loade links
 	 * @param klass
 	 *            The class of the loaded node
 	 * @throws Exception
 	 */
 	private void loadLinks(Node node, Mappable object, Class<Mappable> klass) throws Exception {
 		if (Helper.isSuperMapped(klass)) {
 			loadLinks(node, object, (Class<Mappable>)klass.getSuperclass());
 		}
 
 		// System.out.println("Loading... " + klass.getSimpleName() +" " +
 		// object);
 		for (LinkEntry entry : Helper.getMappedLinks(klass)) {
 
 			MapLink linkMapping = entry.getAnnotation();
 			Direction direction = linkMapping.direction();
 
 			// node.reloadLinks();
 			List<Link> links = node.links(linkMapping.name(), direction);
 			String setterName = null;
 			// rebuild all objects which are at the opposite site of the
 			// link
 			List<Mappable> linkedElements = new LinkedList<Mappable>();
 			for (Link link : links) {
 				if (direction == Direction.SRC) {
 					// on this side the setter name must be the same for all
 					// linked elements, so we can set the setter name once
 					if (setterName == null) {
 						setterName = SET_PREFIX + link.getSrcAccessor(); //$NON-NLS-1$
 					}
 					// load the object on the opposit side
 					linkedElements.add(load(link.getDst()));
 				} else {
 					if (setterName == null) {
 						setterName = SET_PREFIX + link.getDstAccessor(); //$NON-NLS-1$
 					}
 					linkedElements.add(load(link.getSrc()));
 				}
 			}
 			if (linkMapping.load().equals(Object.class)) {
 				// default loading mechanizm
 				if (linkedElements.size() == 0) {
 					// no linked elements found
 
 					// TODO introduce obligatory links (?)
 					// if(!linkMapping.collection())
 					// throw new RuntimeException("No value for singular
 					// link "+
 					// linkMapping.name() + " for " + klass +
 					// " [" + node.getId() + "]");
 					// }
 				} else {
 					if (setterName == null) {
 						throw new RuntimeException("Metamodel error: missing link setter for " //$NON-NLS-1$
 						        + "link " + linkMapping.name() //$NON-NLS-1$
 						        + " for " + klass + " [" //$NON-NLS-1$ //$NON-NLS-2$
 						        + node.getId() + "]"); //$NON-NLS-1$
 					}
 					Type klass2 = entry.getMethod().getReturnType();
 					if (klass2 != null && klass2.equals(List.class)) {
 						Method setter = object.getClass().getMethod(setterName, List.class);
 						setter.invoke(object, new Object[] { linkedElements });
 					} else {
 						if (linkedElements.size() > 1) {
 							throw new RuntimeException("Too many values for singular link " //$NON-NLS-1$
 							        + linkMapping.name() + " for " //$NON-NLS-1$
 							        + klass + " [" + node.getId() //$NON-NLS-1$
 							        + "]"); //$NON-NLS-1$
 						}
 						Object linkedElement = linkedElements.get(0);
 						Method setter = Helper.getSetter(object, linkedElement, setterName);
 						setter.invoke(object, new Object[] { linkedElement });
 					}
 				}
 			} else {
 				Constructor cons = linkMapping.load().getConstructor(new Class[] { klass });
 				LinkLoader loader = (LinkLoader)cons.newInstance(new Object[] { object });
 				loader.loadLink(linkedElements);
 			}
 		}
 	}
 
 	/**
 	 * Load attributes of given node
 	 *
 	 * @param node
 	 *            Node whos links are loaded
 	 * @param object
 	 *            The object which owns loaded attributes
 	 * @param The
 	 *            type map
 	 * @see pl.edu.agh.cast.model.base.metamodel.annotation.Mapping
 	 * @param klass
 	 *            The class of the loaded node
 	 * @throws Exception
 	 */
 	private void loadAttributes(Node node, Mappable object, Class<Mappable> klass) throws Exception {
 		if (Helper.isSuperMapped(klass)) {
 			loadAttributes(node, object, (Class<Mappable>)klass.getSuperclass());
 		}
 
 		for (Method method : Helper.mappedAttributeMethods(klass)) {
 			MapAttribute attributeMapping = method.getAnnotation(MapAttribute.class);
 			String attributeName = attributeMapping.name();
 			if (attributeName.equals("")) { //$NON-NLS-1$
 				attributeName = method.getName();
 			}
 			try {
 				List<Link> links = node.links(attributeName);
 				if (attributeMapping.load().equals(Object.class)) {
 					// default implementation
 					// TODO array attributes
 					if (links.size() > 1) {
 						throw new RuntimeException("Too many values for attribute " //$NON-NLS-1$
 						        + attributeName + " for " + klass + "[" //$NON-NLS-1$ //$NON-NLS-2$
 						        + node.getId() + "]"); //$NON-NLS-1$
 					} else if (links.size() != 1) {
 						// TODO set to null by default?
 						// add flag to the annotation indicating if the
 						// value may be missing at initialization
 						throw new RuntimeException("Missing value for attribute " + attributeName //$NON-NLS-1$
 						        + " for " + klass + "[" + node.getId() //$NON-NLS-1$ //$NON-NLS-2$
 						        + "]"); //$NON-NLS-1$
 					} else {
 						String setterName = SET_PREFIX + method.getName().substring(3);
 						Method setterMethod = klass.getMethod(setterName, method.getReturnType());
 						Object value = links.get(0).getSrc().getValue();
 						try {
 							setterMethod.invoke(object, new Object[] { value });
 						} catch (IllegalArgumentException ex) {
 							if (value instanceof Long) {
 								Integer intValue = ((Long)value).intValue();
 								setterMethod.invoke(object, new Object[] { intValue });
 							}
 						}
 					}
 				} else {
 					Constructor cons = attributeMapping.load().getConstructor(new Class[] { klass });
 					AttributeLoader loader = (AttributeLoader)cons.newInstance(new Object[] { object });
 					loader.loadAttribute(node, links);
 				}
 			} catch (NoSuchMethodException e) {
 				throw new RuntimeException("Missing setter for attribute " //$NON-NLS-1$
 				        + attributeName + " for " + klass, e); //$NON-NLS-1$
 			}
 		}
 	}
 
 }