/*
 * Copyright (C) 2005-2009 Alfresco Software Limited.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 * As a special exception to the terms and conditions of version 2.0 of 
 * the GPL, you may redistribute this Program in connection with Free/Libre 
 * and Open Source Software ("FLOSS") applications as described in Alfresco's 
 * FLOSS exception.  You should have recieved a copy of the text describing 
 * the FLOSS exception, and it is also available here: 
 * http://www.alfresco.com/legal/licensing"
 */
package org.alfresco.repo.domain.avm;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import org.alfresco.error.AlfrescoRuntimeException;
import org.alfresco.repo.cache.NullCache;
import org.alfresco.repo.cache.SimpleCache;
import org.alfresco.util.Pair;
import org.alfresco.util.ParameterCheck;
import org.springframework.dao.ConcurrencyFailureException;

/**
 * Abstract implementation for AVMVersionRoot DAO.
 * <p>
 * This provides basic services such as caching but defers to the underlying implementation
 * for CRUD operations.
 * 
 * @author janv
 * @since 3.2
 */
public abstract class AbstractAVMVersionRootDAOImpl implements AVMVersionRootDAO
{
    private SimpleCache<Serializable, Serializable> vrEntityCache;
    
    /**
     * Set the cache to use for <b>avm_version_roots</b> lookups (optional).
     * 
     * @param vrEntityCache
     */
    public void setVersionRootEntityCache(SimpleCache<Serializable, Serializable> vrEntityCache)
    {
        this.vrEntityCache = vrEntityCache;
    }
    
    @SuppressWarnings("unchecked")
    public AbstractAVMVersionRootDAOImpl()
    {
        this.vrEntityCache = (SimpleCache<Serializable, Serializable>)new NullCache();
    }
    
    /**
     * {@inheritDoc}
     */
    public AVMVersionRootEntity createVersionRoot(long storeId, long rootNodeId, int version, String creator, String tag, String description)
    {
        ParameterCheck.mandatory("creator", creator);
        
        AVMVersionRootEntity vrEntity = new AVMVersionRootEntity();
        vrEntity.setStoreId(storeId);
        vrEntity.setRootNodeId(rootNodeId);
        vrEntity.setVersion(version);
        vrEntity.setCreator(creator);
        vrEntity.setCreatedDate(new Date().getTime()); // app server date/time
        vrEntity.setTag(tag);
        vrEntity.setDescription(description);
        
        vrEntity = createVersionRootEntity(vrEntity);
        
        // Cache it
        vrEntityCache.put(new Pair<Long, Integer>(storeId, version), vrEntity.getId());
        vrEntityCache.put(vrEntity.getId(), vrEntity);
        
        return vrEntity;
    }
    
    /**
     * {@inheritDoc}
     */
    public void updateVersionRoot(AVMVersionRootEntity vrEntity)
    {
        ParameterCheck.mandatory("vrEntity", vrEntity);
        
        ParameterCheck.mandatory("vrEntity.storeId", vrEntity.getStoreId());
        ParameterCheck.mandatory("vrEntity.id", vrEntity.getId());
        ParameterCheck.mandatory("vrEntity.version", vrEntity.getVersion());
        
        updateVersionRootEntity(vrEntity);
        
        // Cache it
        vrEntityCache.put(new Pair<Long, Integer>(vrEntity.getStoreId(), vrEntity.getVersion()), vrEntity.getId());
        vrEntityCache.put(vrEntity.getId(), vrEntity);
    }
    
    /**
     * {@inheritDoc}
     */
    public List<AVMVersionRootEntity> getAllInStore(long storeId)
    {
        return getAllVersionRootEntitiesByStoreId(storeId);
    }
    
    /**
     * {@inheritDoc}
     */
    protected AVMVersionRootEntity getByID(long vrEntityId)
    {
        AVMVersionRootEntity vrEntity = (AVMVersionRootEntity) vrEntityCache.get(vrEntityId);
        if (vrEntity != null)
        {
            return vrEntity;
        }
        
        // Get it from the DB
        vrEntity = getVersionRootEntityById(vrEntityId);
        if (vrEntity != null)
        {
            // Cache it
            vrEntityCache.put(new Pair<Long, Integer>(vrEntity.getStoreId(), vrEntity.getVersion()), vrEntity.getId());
            vrEntityCache.put(vrEntity.getId(), vrEntity);
        }
        
        return vrEntity;
    }
    
    /**
     * {@inheritDoc}
     */
    public AVMVersionRootEntity getByVersionID(long storeId, int version)
    {
        // Check the cache
        Long vrEntityId = (Long) vrEntityCache.get(new Pair<Long, Integer>(storeId, version));
        AVMVersionRootEntity vrEntity = null;
        if (vrEntityId != null)
        {
            vrEntity = (AVMVersionRootEntity) vrEntityCache.get(vrEntityId);
            if (vrEntity != null)
            {
                return vrEntity;
            }
        }
        
        // Get it from the DB
        vrEntity = getVersionRootEntityByStoreVersion(storeId, version);
        if (vrEntity != null)
        {
            // Cache it
            vrEntityCache.put(new Pair<Long, Integer>(vrEntity.getStoreId(), vrEntity.getVersion()), vrEntity.getId());
            vrEntityCache.put(vrEntity.getId(), vrEntity);
        }
        
        return vrEntity;
    }
    
    /**
     * {@inheritDoc}
     */
    public AVMVersionRootEntity getByRoot(long rootNodeId)
    {
        return getVersionRootEntityByRootNodeId(rootNodeId);
    }
    
    /**
     * {@inheritDoc}
     */
    public List<AVMVersionRootEntity> getByDates(long storeId, Date from, Date to)
    {
        if ((from != null) && (to != null))
        {
            return getVersionRootEntitiesByBetween(storeId, from.getTime(), to.getTime());
        }
        else if ((from == null) && (to != null))
        {
            return getVersionRootEntitiesByTo(storeId, to.getTime());
        }
        else if ((to == null) && (from != null))
        {
            return getVersionRootEntitiesByFrom(storeId, from.getTime());
        }
        else
        {
            throw new AlfrescoRuntimeException("getByDates: from and to are both null for store id: "+storeId);
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public AVMVersionRootEntity getMaxVersion(long storeId)
    {
        return getVersionRootEntityMaxVersion(storeId);
    }
    
    /**
     * {@inheritDoc}
     */
    public Long getMaxVersionID(long storeId)
    {
        return getVersionRootEntityMaxVersionId(storeId);
    }
    
    /**
     * {@inheritDoc}
     */
    public void deleteVersionRoot(long vrEntityId)
    {
        AVMVersionRootEntity vrEntity = getByID(vrEntityId);
        if (vrEntity == null)
        {
            return;
        }
        
        int deleted = deleteVersionRootEntity(vrEntityId);
        if (deleted < 1)
        {
            throw new ConcurrencyFailureException("AVMVersionRoot with ID " + vrEntityId + " no longer exists");
        }
        
        // Remove from cache
        vrEntityCache.remove(new Pair<Long, Integer>(vrEntity.getStoreId(), vrEntity.getVersion()));
        vrEntityCache.remove(vrEntityId);
    }
    
    protected abstract AVMVersionRootEntity createVersionRootEntity(AVMVersionRootEntity vrEntity);
    protected abstract void updateVersionRootEntity(AVMVersionRootEntity updateVersionRootEntity);
    protected abstract int deleteVersionRootEntity(long vrEntityId);
    protected abstract AVMVersionRootEntity getVersionRootEntityMaxVersion(long storeId);
    protected abstract Long getVersionRootEntityMaxVersionId(long storeId);
    protected abstract AVMVersionRootEntity getVersionRootEntityById(long vrEntityId);
    protected abstract AVMVersionRootEntity getVersionRootEntityByStoreVersion(long storeId, int version);
    protected abstract AVMVersionRootEntity getVersionRootEntityByRootNodeId(long rootNodeId);
    protected abstract List<AVMVersionRootEntity> getAllVersionRootEntitiesByStoreId(long storeId);
    protected abstract List<AVMVersionRootEntity> getVersionRootEntitiesByTo(long storeId, long to);
    protected abstract List<AVMVersionRootEntity> getVersionRootEntitiesByFrom(long storeId, long from);
    protected abstract List<AVMVersionRootEntity> getVersionRootEntitiesByBetween(long storeId, long from, long to);
    
    /**
     * {@inheritDoc}
     */
    public AVMVersionLayeredNodeEntryEntity createVersionLayeredNodeEntry(long versionRootId, String md5sum, String path)
    {
        ParameterCheck.mandatory("md5sum", md5sum);
        ParameterCheck.mandatory("path", path);
        
        return createVersionLayeredNodeEntryEntity(versionRootId, md5sum, path);
    }
    
    /**
     * {@inheritDoc}
     */
    public void deleteVersionLayeredNodeEntries(long versionRootId)
    {
        List<AVMVersionLayeredNodeEntryEntity> vlneEntities = getVersionLayeredNodeEntries(versionRootId);
        if (vlneEntities.size() == 0)
        {
            return;
        }
        
        int deleted = deleteVersionLayeredNodeEntryEntities(versionRootId);
        if (deleted < 1)
        {
            throw new ConcurrencyFailureException("AVMVersionLayeredNodeEntries with version root id " + versionRootId + " no longer exist");
        }
    }
    
    /**
     * {@inheritDoc}
     */
    public List<AVMVersionLayeredNodeEntryEntity> getVersionLayeredNodeEntries(long versionRootId)
    {
        return getVersionLayeredNodeEntryEntities(versionRootId);
    }
    
    protected abstract AVMVersionLayeredNodeEntryEntity createVersionLayeredNodeEntryEntity(long versionRootId, String md5sum, String path);
    protected abstract int deleteVersionLayeredNodeEntryEntities(long versionRootId);
    protected abstract List<AVMVersionLayeredNodeEntryEntity> getVersionLayeredNodeEntryEntities(long storeId);
}