/*
    * Copyright (c) 2007, James Leigh All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.dynabean;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.WeakHashMap;
  
  import org.apache.commons.beanutils.DynaBean;
  import org.apache.commons.beanutils.DynaClass;
  import org.openrdf.elmo.Entity;
  import org.openrdf.elmo.dynabean.helpers.DynaClassInfo;
  import org.openrdf.elmo.dynabean.helpers.DynaClassInfoFactory;
  import org.openrdf.elmo.exceptions.ElmoIOException;
  import org.openrdf.elmo.exceptions.ElmoPersistException;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.sesame.SesameProperty;
  import org.openrdf.elmo.sesame.helpers.PropertyChanger;
  import org.openrdf.elmo.sesame.roles.SesameEntity;
  import org.openrdf.model.BNode;
  import org.openrdf.model.Resource;
  import org.openrdf.model.URI;
  import org.openrdf.model.ValueFactory;
  import org.openrdf.model.vocabulary.RDF;
  import org.openrdf.repository.Repository;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  
  /**
   * DynaBean interface for Elmo JavaBeans. Property names can be in one of three
   * supported formats:
   * <ul>
   * <li>local-name of the property that existing in an ontology in the
   * repository;</li>
   * <li>prefix:local-name of the property, where the prefix is defined in the
   * repository;</li>
   * <li>uri of the property.</li>
   * </ul>
   * Unless the local-name format is used and the property is either functional or
   * has a cardinality of one, the property type will be a java.uti.Set.
   * 
   * @author James Leigh
   * @see DynaClassSupport
   * 
   */
  @SuppressWarnings("unchecked")
  public class DynaBeanSupport implements DynaBean {
  
  	private static WeakHashMap<Repository, DynaClassInfoFactory> factories = new WeakHashMap();
  
  	private SesameManager manager;
  
  	private SesameEntity bean;
  
  	private DynaClassInfo dynaClassInfo;
  
  	private Map<String, SesameProperty> properties = new HashMap<String, SesameProperty>();
  
  	public DynaBeanSupport(Entity elmo) {
  		this.bean = (SesameEntity) elmo;
  		this.manager = bean.getSesameManager();
  		DynaClassInfoFactory factory;
  		Repository repository;
  		repository = manager.getConnection().getRepository();
  		synchronized (factories) {
  			factory = factories.get(repository);
  			if (factory == null) {
  				factory = new DynaClassInfoFactory();
  				factories.put(repository, factory);
  			}
 		}
 		Resource resource = bean.getSesameResource();
 		this.dynaClassInfo = factory.findDyanClass(manager, resource);
 	}
 
 	public DynaClass getDynaClass() {
 		DynaClassSupport c = new DynaClassSupport(bean);
 		c.setDynaClassInfo(dynaClassInfo);
 		return c;
 	}
 
 	@SuppressWarnings("unchecked")
 	private SesameProperty getSesameProperty(String property) {
 		if (properties.containsKey(property))
 			return properties.get(property);
 		URI pred = getPredicate(property);
 		assert pred != null;
 		PropertyChanger pc = new PropertyChanger(pred);
 		SesameProperty sp = new SesameProperty(bean, pc);
 		properties.put(property, sp);
 		return sp;
 	}
 
 	private URI getPredicate(String property) {
 		int colon = property.indexOf(':');
 		if (colon < 0)
 			return dynaClassInfo.getPredicate(property);
 		ContextAwareConnection conn = manager.getConnection();
 		ValueFactory vf = conn.getRepository().getValueFactory();
 		for (int i = colon + 1, n = property.length(); i < n; i++) {
 			switch (property.charAt(i)) {
 			case ':':
 			case '/':
 			case '#':
 				return vf.createURI(property);
 			}
 		}
 		try {
 			String ns = conn.getNamespace(property.substring(0, colon));
 			if (ns == null) {
 				String msg = "Unknown prefix in property: " + property;
 				throw new IllegalArgumentException(msg);
 			}
 			return vf.createURI(ns, property.substring(colon + 1));
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public Object get(String property) {
 		if (dynaClassInfo.isFunctional(property))
 			return getSesameProperty(property).getSingle();
 		return getSesameProperty(property);
 	}
 
 	public void set(String property, Object value) {
 		boolean func = dynaClassInfo.isFunctional(property);
 		if (value == null) {
 			getSesameProperty(property).clear();
 		} else if (!func && value instanceof Set) {
 			getSesameProperty(property).setAll((Set<?>) value);
 		} else {
 			getSesameProperty(property).setSingle(value);
 		}
 	}
 
 	public Object get(String property, int index) {
 		assert dynaClassInfo.isFunctional(property) : dynaClassInfo
 				.getDynaProperty(property);
 		SesameProperty sp = getSesameProperty(property);
 		List list = (List) sp.getSingle();
 		if (list == null)
 			return null;
 		return list.get(index);
 	}
 
 	@SuppressWarnings("unchecked")
 	public void set(String property, int index, Object value) {
 		assert dynaClassInfo.isFunctional(property) : dynaClassInfo
 				.getDynaProperty(property);
 		SesameProperty sp = getSesameProperty(property);
 		List<Object> list = (List) sp.getSingle();
 		if (list == null && value == null) {
 			return;
 		} else if (list == null) {
 			Collection<URI> types = dynaClassInfo.getRdfTypes(property);
 			ContextAwareConnection conn = manager.getConnection();
 			ValueFactory vf = conn.getRepository().getValueFactory();
 			BNode bNode = vf.createBNode();
 			try {
 				for (URI rdfType : types) {
 					conn.add(bNode, RDF.TYPE, rdfType);
 				}
 			} catch (RepositoryException e) {
 				throw new ElmoPersistException(e);
 			}
 			list = (List<Object>) manager.find(bNode);
 			list.add(value);
 			getSesameProperty(property).setSingle(list);
 		} else if (index == list.size()) {
 			if (value != null)
 				list.add(value);
 		} else if (value == null) {
 			list.remove(index);
 		} else {
 			list.set(index, value);
 		}
 	}
 
 	public Object get(String property, String key) {
 		if (!getDynaClass().getDynaProperty(property).isMapped())
 			throw new UnsupportedOperationException();
 		assert dynaClassInfo.isFunctional(property) : dynaClassInfo
 				.getDynaProperty(property);
 		SesameProperty sp = getSesameProperty(property);
 		Map map = (Map) sp.getSingle();
 		if (map == null)
 			return null;
 		return map.get(key);
 	}
 
 	@SuppressWarnings("unchecked")
 	public void set(String property, String key, Object value) {
 		if (!getDynaClass().getDynaProperty(property).isIndexed())
 			throw new UnsupportedOperationException();
 		assert dynaClassInfo.isFunctional(property) : dynaClassInfo
 				.getDynaProperty(property);
 		SesameProperty sp = getSesameProperty(property);
 		Map<String, Object> map = (Map) sp.getSingle();
 		if (map == null) {
 			Collection<URI> types = dynaClassInfo.getRdfTypes(property);
 			ContextAwareConnection conn = manager.getConnection();
 			ValueFactory vf = conn.getRepository().getValueFactory();
 			BNode bNode = vf.createBNode();
 			try {
 				for (URI rdfType : types) {
 					conn.add(bNode, RDF.TYPE, rdfType);
 				}
 			} catch (RepositoryException e) {
 				throw new ElmoPersistException(e);
 			}
 			map = (Map<String, Object>) manager.find(bNode);
 			map.put(key, value);
 			getSesameProperty(property).setSingle(map);
 		} else if (value == null) {
 			map.remove(key);
 		} else {
 			map.put(key, value);
 		}
 	}
 
 	public boolean contains(String property, String key) {
 		if (!getDynaClass().getDynaProperty(property).isMapped())
 			throw new UnsupportedOperationException();
 		assert dynaClassInfo.isFunctional(property);
 		SesameProperty sp = getSesameProperty(property);
 		Map map = (Map) sp.getSingle();
 		if (map == null)
 			return false;
 		return map.containsKey(key);
 	}
 
 	public void remove(String property, String key) {
 		if (!getDynaClass().getDynaProperty(property).isMapped())
 			throw new UnsupportedOperationException();
 		assert dynaClassInfo.isFunctional(property);
 		SesameProperty sp = getSesameProperty(property);
 		Map map = (Map) sp.getSingle();
 		if (map != null)
 			map.remove(key);
 	}
 
 }