EDIT

/**

 * Copyright (C) 2014 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.taxeditor.session;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import eu.etaxonomy.cdm.api.service.IService;

import eu.etaxonomy.cdm.api.service.UpdateResult;

import eu.etaxonomy.cdm.cache.CdmTransientEntityCacher;

//import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;

import eu.etaxonomy.cdm.cache.EntityCacherDebugResult;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;

import eu.etaxonomy.cdm.persistence.dto.MergeResult;

import eu.etaxonomy.taxeditor.remoting.cache.ConversationalTransientEntityCacher;

import net.sf.ehcache.statistics.FlatStatistics;

/**

 * NOTE : It would be nice to have this class performing merge / delete operations

 * using services, but this is only possible if we can 'intelligently'

 * get from a model class to the corresponding service class

 *

 * @author cmathew

 * @date 20 Oct 2014

 */

public class CdmEntitySession implements ICdmEntitySession  {

    private static final Logger logger = LogManager.getLogger(CdmEntitySession.class);

    private final CdmEntitySessionManager cdmEntitySessionManager;

    private final ICdmEntitySessionEnabled sessionOwner;

    private ConversationalTransientEntityCacher cdmTransientEntityCacher;

    private List<ICdmEntitySessionEnabled> changeObservers;

    public CdmEntitySession(ICdmEntitySessionEnabled sessionOwner, CdmEntitySessionManager cdmEntitySessionManager) {

        this.sessionOwner = sessionOwner;

        this.cdmEntitySessionManager = cdmEntitySessionManager;

        init(sessionOwner, cdmEntitySessionManager);

    }

    private void init(ICdmEntitySessionEnabled sessionOwner, CdmEntitySessionManager cdmEntitySessionManager) {

        this.cdmTransientEntityCacher = new ConversationalTransientEntityCacher(sessionOwner);

        this.changeObservers = new ArrayList<>();

        cdmEntitySessionManager.addToOwnerSessionMap(sessionOwner, this);

    }

    @Override

    public  <O extends Object> O load(O obj, boolean update) {

        return cdmTransientEntityCacher.load(obj, update);

    }

    @Override

    public  <T extends CdmBase> T load(T cdmBase, boolean update) {

        return cdmTransientEntityCacher.load(cdmBase, update);

    }

    @Override

    public UpdateResult load(UpdateResult updateResult, boolean update) {

        return cdmTransientEntityCacher.load(updateResult, update);

    }

    @Override

    public  <T extends CdmBase> MergeResult<T> load(MergeResult<T> mergeResult, boolean update) {

        return  cdmTransientEntityCacher.load(mergeResult, update);

    }

    @Override

    public <T extends CdmBase> void  update() {

        Collection<T> rootEntities = getRootEntities();

        if(rootEntities != null) {

            for(T rootEntity : rootEntities) {

                load(rootEntity, true);

            }

        }

    }

//    @Override

//    public <T extends ICdmBase> void update(T cdmBase, Set<CdmBase> affectedObjects) {

//        addEvent(cdmBase, affectedObjects, EventType.UPDATE);

//    }

//

//    @Override

//    public <T extends ICdmBase> void update(T cdmBase, CdmBase affectedObject) {

//        Set<CdmBase> set = new HashSet<CdmBase>();

//        set.add(affectedObject);

//        addEvent(cdmBase, set, EventType.UPDATE);

//    }

//

//

//    @Override

//    public <T extends ICdmBase> void delete(T cdmBase, Set<CdmBase> affectedObjects) {

//        addEvent(cdmBase, affectedObjects, EventType.DELETE);

//    }

//

//    @Override

//    public <T extends ICdmBase> void delete(Set<T> cdmBases, Set<CdmBase> affectedObjects) {

//        addEvent(cdmBases, affectedObjects, EventType.DELETE);

//    }

    @Override

    public <T extends CdmBase> EntityCacherDebugResult debug(T cdmBase) {

        return debug(Arrays.asList(cdmBase), true);

    }

    @Override

    public <T extends CdmBase> EntityCacherDebugResult debug(Collection<T> rootEntities, boolean includeIgnored) {

        EntityCacherDebugResult entityCacherDebugResult =

                new EntityCacherDebugResult(cdmTransientEntityCacher, rootEntities, includeIgnored);

        return entityCacherDebugResult;

    }

    @Override

    public <T extends CdmBase> EntityCacherDebugResult debug(boolean includeIgnored) {

        return debug(getRootEntities(), includeIgnored);

    }

    @Override

    public  <T extends CdmBase> Collection<T> load(Collection<T> cdmBaseList, boolean update) {

        return cdmTransientEntityCacher.load(cdmBaseList, update);

    }

    @Override

    public void setEntitiesAsLatest() {

        //FIXME:Remoting need to think more about whether we really need this

        //		List<CdmBase> entities = cdmTransientEntityCacher.getAllEntities();

        //		for(CdmBase entity : entities) {

        //			cdmEntitySessionManager.setEntityAsLatest(entity);

        //		}

    }

    @Override

    public void bind() {

        logger.info("Binding session with owner " + sessionOwner.toString());

        if(!cdmEntitySessionManager.contains(sessionOwner)) {

            init(sessionOwner, cdmEntitySessionManager);

        }

        cdmEntitySessionManager.bind(sessionOwner);

    }

    @Override

    public void dispose() {

        cdmTransientEntityCacher.dispose();

        changeObservers.clear();

        cdmEntitySessionManager.remove(sessionOwner);

    }

//    @Override

//    public void addEvent(ICdmBase cdmBase, Set<CdmBase> affectedObjects, EventType eventType) {

//        affectedObjects = (Set<CdmBase>) load(affectedObjects, true);

//        CdmDataChangeEvent cdce = CdmDataChangeEvent.NewInstance((CdmBase)cdmBase, affectedObjects, eventType);

//        CdmPostDataChangeObservableListener.getDefault().notifyObservers(cdce);

//    }

    /**

     *  Returns a persisted entity specified by the <code>uuid</code>

     *  or null if the entity does not exist,

     *  loads it to the entityCacher

     *

     * @param service

     * @param uuid

     *

     * @return

     */

    @Override

    public  <T extends CdmBase>  T remoteLoad(IService<T> service, UUID uuid) {

        T cdmBase = service.load(uuid);

        return load(cdmBase, false);

    }

    /**

     * Returns the cdm entity specified by the <code>uuid</code>,

     * recursively initializes all bean properties given in the

     * <code>propertyPaths</code> parameter,

     * the loaded entity is also loaded to the entityCache

     * <p>

     * For detailed description and examples <b>please refer to:</b>

     * {@link IBeanInitializer#initialize(Object, List)}

     *

     * @param service

     * @param uuid

     * @param propertyPath

     *

     * @return

     */

    @Override

    public <T extends CdmBase>  T remoteLoad(IService<T> service, UUID uuid, List<String> propertyPaths) {

        T cdmBase = service.load(uuid, propertyPaths);

        return load(cdmBase, false);

    }

    @Override

    public <T extends CdmBase> UUID remoteSave(IService<T> service, T cdmBase) {

        UUID uuid = service.save(cdmBase).getUuid();

        load(cdmBase,false);

        return uuid;

    }

    @Override

    public <T extends CdmBase> T remoteUpdate(IService<T> service, T cdmBase) {

        T mergedCdmBase = service.merge(cdmBase, true).getMergedEntity();

        return mergedCdmBase;

    }

    @Override

    public boolean isActive() {

        return cdmEntitySessionManager.getActiveSession() == this;

    }

    @Override

    public ICdmEntitySessionEnabled getOwner() {

        return sessionOwner;

    }

    @Override

    public FlatStatistics getCacheStatistics() {

        return cdmTransientEntityCacher.getCacheStatistics();

    }

    @Override

    public <T extends CdmBase> Collection<T> getRootEntities() {

        return sessionOwner.getRootEntities();

    }

    public CdmTransientEntityCacher getCacher() {

        return cdmTransientEntityCacher;

    }

    @Override

    public List<String> getPropertyPaths(Object obj) {

        Map<Object, List<String>> propertyPathsMap = sessionOwner.getPropertyPathsMap();

        if(propertyPathsMap == null || propertyPathsMap.isEmpty()) {

            return null;

        }

        return propertyPathsMap.get(obj);

    }

    //this method is called by DefaultNewEntityListener whenever

    //a new entity is created (constructor call) while the current

    //session is active

    @Override

    public void addNewCdmEntity(CdmBase newEntity) {

        cdmTransientEntityCacher.load(newEntity);

    }

}