root/trunk/cdmlib/cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/WorkingSet.java

// $Id$
/**
* Copyright (C) 2007 EDIT
* European Distributed Institute of Taxonomy 
* http://www.e-taxonomy.eu
* 
* The contents of this file are subject to the Mozilla Public License Version 1.1
* See LICENSE.TXT at the top of this package for the full license terms.
*/

package eu.etaxonomy.cdm.model.description;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Map.Entry;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Transient;
import javax.validation.constraints.NotNull;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;

import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.envers.Audited;

import eu.etaxonomy.cdm.model.common.AnnotatableEntity;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.Representation;

/**
 * 
 * The working set class allows the demarcation of a set of descriptions
 * associated with representations and a set of features and their
 * dependencies.
 * 
 * @author h.fradin
 * @created 12.08.2009
 * @version 1.0
 */

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "WorkingSet", propOrder = {
    "representations",
    "descriptiveSystem",
    "descriptions"
})
@XmlRootElement(name = "WorkingSet")
@Entity
@Audited

public class WorkingSet extends AnnotatableEntity {
        private static final long serialVersionUID = 3256448866757415686L;
        private static final Logger logger = Logger.getLogger(WorkingSet.class);
        
        @XmlElementWrapper(name = "Representations")
        @XmlElement(name = "Representation")
    @OneToMany(fetch=FetchType.EAGER)
        @Cascade( { CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE })
        private Set<Representation> representations = new HashSet<Representation>();
        
        @XmlElement(name = "DescriptiveSystem")
        @XmlIDREF
        @XmlSchemaType(name = "IDREF")
        @ManyToOne(fetch = FetchType.LAZY)
        @Cascade({CascadeType.SAVE_UPDATE})
        private FeatureTree descriptiveSystem;
        
        @XmlElementWrapper(name = "Descriptions")
        @XmlElement(name = "Description")
    @XmlIDREF
    @XmlSchemaType(name = "IDREF")
    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(
        name="WorkingSet_DescriptionBase",
        joinColumns=@JoinColumn(name="WorkingSet_id"),
        inverseJoinColumns=@JoinColumn(name="descriptions_id")
    )
        @Cascade(CascadeType.SAVE_UPDATE)
        @NotNull
        private Set<DescriptionBase> descriptions = new HashSet<DescriptionBase>();
        
        /** 
         * Class constructor: creates a new empty working set instance.
         */
        protected WorkingSet() {
                super();
        }
        
        /** 
         * Creates a new empty working set instance.
         */
        public static WorkingSet NewInstance(){
                return new WorkingSet();
        }
        
        public Set<Representation> getRepresentations() {
                return this.representations;
        }

        public void addRepresentation(Representation representation) {
                this.representations.add(representation);
        }

        public void removeRepresentation(Representation representation) {
                this.representations.remove(representation);
        }

        public Representation getRepresentation(Language lang) {
                for (Representation repr : representations){
                        Language reprLanguage = repr.getLanguage();
                        if (reprLanguage != null && reprLanguage.equals(lang)){
                                return repr;
                        }
                }
                return null;
        }
        
        /**
         * @see #getPreferredRepresentation(Language)
         * @param language
         * @return
         */
        public Representation getPreferredRepresentation(Language language) {
                Representation repr = getRepresentation(language); 
                if(repr == null){
                        repr = getRepresentation(Language.DEFAULT());
                }
                if(repr == null){
                        repr = getRepresentations().iterator().next();
                }
                return repr;
        }
        
        /**
         * Returns the Representation in the preferred language. Preferred languages
         * are specified by the parameter languages, which receives a list of
         * Language instances in the order of preference. If no representation in
         * any preferred languages is found the method falls back to return the
         * Representation in Language.DEFAULT() and if necessary further falls back
         * to return the first element found if any.
         * 
         * TODO think about this fall-back strategy & 
         * see also {@link TextData#getPreferredLanguageString(List)}
         * 
         * @param languages
         * @return
         */
        public Representation getPreferredRepresentation(List<Language> languages) {
                Representation repr = null;
                if(languages != null){
                        for(Language language : languages) {
                                repr = getRepresentation(language); 
                                if(repr != null){
                                        return repr;
                                }
                        }
                }
                if(repr == null){
                        repr = getRepresentation(Language.DEFAULT());
                }
                if(repr == null){
                        Iterator<Representation> it = getRepresentations().iterator();
                        if(it.hasNext()){
                                repr = getRepresentations().iterator().next();
                        }
                }
                return repr;
        }
        
        @Transient
        public String getLabel() {
                if(getLabel(Language.DEFAULT())!=null){
                        Representation repr = getRepresentation(Language.DEFAULT());
                        return (repr == null)? null :repr.getLabel();
                }else{
                        for (Representation r : representations){
                                return r.getLabel();
                        }                       
                }
                return super.getUuid().toString();
        }
        
        public String getLabel(Language lang) {
                Representation repr = this.getRepresentation(lang);
                return (repr == null) ? null : repr.getLabel();
        }       
        
        public void setLabel(String label){
                Language lang = Language.DEFAULT();
                setLabel(label, lang);
        }

        public void setLabel(String label, Language language){
                if (language != null){
                        Representation repr = getRepresentation(language);
                        if (repr != null){
                                repr.setLabel(label);
                        }else{
                                repr = Representation.NewInstance(null, label, null, language);
                        }
                        this.addRepresentation(repr);
                }
        }
        
        public FeatureTree getDescriptiveSystem() {
                return descriptiveSystem;
        }
        public void setDescriptiveSystem(FeatureTree descriptiveSystem) {
                this.descriptiveSystem = descriptiveSystem;
        }
        
        /**
         * Returns the {@link DescriptionBase descriptions} of
         * <i>this</i> working set.
         * 
         * @see    #addDescription(DescriptionBase)
         * @see    #removeDescription(DescriptionBase)
         */
        public Set<DescriptionBase> getDescriptions() {
                return descriptions;
        }
        
        /**
         * Adds an existing {@link DescriptionBase description} to the set of
         * {@link #getDescriptions() descriptions} of <i>this</i>
         * working set.
         * 
         * @param description   the description to be added to <i>this</i> working set
         * @see                                 #getDescriptions()
         * @see                                 WorkingSet#addDescription(DescriptionBase)
         */
        public boolean addDescription(DescriptionBase description) {
                boolean result = this.descriptions.add(description);
                if (! description.getWorkingSets().contains(this)){
                        description.addWorkingSet(this);
                }
                return result;
        }
        
        /** 
         * Removes one element from the set of {@link #getDescriptions() descriptions} involved
         * in <i>this</i> working set.<BR>
         *
         * @param  description  the description which should be removed
         * @see                         #getDescriptions()
         * @see                         #addDescription(DescriptionBase)
         * @see                         WorkingSet#removeDescription(DescriptionBase)
         */
        public boolean removeDescription(DescriptionBase description) {
                boolean result = this.descriptions.remove(description);
                if (description.getWorkingSets().contains(this)){
                        description.removeWorkingSet(this);
                }
                return result;
        }
        
        //*********************** CLONE ********************************************************/
        
        /** 
         * Clones <i>this</i> WorkingSet. This is a shortcut that enables to create
         * a new instance that differs only slightly from <i>this</i> WorkingSet by
         * modifying only some of the attributes.
         * The descriptions and the descriptive system are the same, the representations 
         * are cloned.
         * 
         * @see eu.etaxonomy.cdm.model.common.AnnotatableEntity#clone()
         * @see java.lang.Object#clone()
         */
        @Override
        public Object clone() {
                WorkingSet result;
                try {
                        result = (WorkingSet)super.clone();
                        result.descriptions = new HashSet<DescriptionBase>();
                        
                        for (DescriptionBase desc: this.descriptions){
                                result.addDescription(desc);
                        }
                        
                        result.representations = new HashSet<Representation>();
                        for (Representation rep : this.representations){
                                result.addRepresentation((Representation)rep.clone());
                        }
                        
                        return result;
                }catch (CloneNotSupportedException e) {
                        logger.warn("Object does not implement cloneable");
                        e.printStackTrace();
                        return null;
                }
        }
        
}