/*
    * Copyright 2006-2010 the original author or authors.
    *
    * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package net.sourceforge.domian.repository;
  
  
  import java.io.File;
  import static java.lang.Boolean.FALSE;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Set;
  
  import static org.apache.commons.lang.SystemUtils.FILE_SEPARATOR;
  import org.apache.commons.lang.Validate;
  
  import net.sourceforge.domian.entity.Entity;
  import net.sourceforge.domian.repository.EntityPersistenceMetaData;
  import net.sourceforge.domian.repository.PersistenceDefinition;
  import static net.sourceforge.domian.repository.PersistenceDefinition.FILE;
  import net.sourceforge.domian.repository.PersistentEntity;
  import net.sourceforge.domian.specification.Specification;
  import net.sourceforge.domian.util.concurrent.locks.SemaphoreSynchronizer;
  import net.sourceforge.domian.util.concurrent.locks.Synchronizer;
  
  import com.thoughtworks.xstream.persistence.PersistenceStrategy;
  import com.thoughtworks.xstream.persistence.XmlSet;
  
  
  /**
   * A persistent repository backed by <a href="http://xstream.codehaus.org">XStream</a> functionality.
   * <p/>
   * The only persistence definition supported by this repository is {@code PersistenceDefinition.FILE}.
   * All repository operations are executed in an exclusive fashion, applying pessimistic locking.
   * Translated into ACID terms, this corresponds to isolation level <code>SERIALIZABLE</code>.
   * <p/>
   * All entities in this repository are persisted into <i>individual XML files</i>.
   * The typical disc footprint is 1KB per entity.
   * The persistence format is human readable XStream XML.
   * The file encoding is UTF-8.
   * <p/>
   * <i>
   * File-based stores counts as persistent storage media,
   * although the nature of the synchronous writings to disc obviously depends on the file system implementations involved.
   * </i>
   * <p/>
   * <i>
   * NB! When used as a partition repository, this repository implementation does not reflect altered state between partitions.
   * When changing state in entities residing in more han one partition,
   * for which at least one of them is a {@code XStreamXmlFilePerEntityRepository},
   * explicit updates for all partitions involved are needed.
   * </i>
   *
   * @author Eirik Torske
   * @see <a href="http://xstream.codehaus.org">XStream</a>
   * @see <a href="http://domian.sourceforge.net/domian-core/apidocs/net/sourceforge/domian/repository/PersistenceDefinition.html#FILE"><code>PersistenceDefinition.FILE</code></a>
   * @since 0.4
   */
  public class XStreamXmlFilePerEntityRepository<T extends Entity> extends AbstractXStreamXmlFilePerEntityRepository<T> {
  
      protected static final String DEFAULT_REPOSITORY_ROOT_DIR_NAME = ".xstream-xml-file-per-entity-repository";
      protected static final String DEFAULT_REPOSITORY_ROOT_PATH = DEFAULT_DOMIAN_ROOT_PATH + FILE_SEPARATOR + DEFAULT_REPOSITORY_ROOT_DIR_NAME;
  
      public XStreamXmlFilePerEntityRepository(final String repositoryId) {
          this(DEFAULT_REPOSITORY_ROOT_PATH, repositoryId);
      }
  
      public XStreamXmlFilePerEntityRepository(final String repositoryId, final Synchronizer synchronizer) {
          this(DEFAULT_REPOSITORY_ROOT_PATH, repositoryId, synchronizer);
      }
  
      public XStreamXmlFilePerEntityRepository(final String repositoryRootPath, final String repositoryId) {
          this(repositoryRootPath, repositoryId, new SemaphoreSynchronizer());
      }
  
      public XStreamXmlFilePerEntityRepository(final String repositoryRootPath, final String repositoryId, final Synchronizer synchronizer) {
          Validate.notEmpty(repositoryRootPath, "The repository root path cannot be empty");
          Validate.notEmpty(repositoryId, "The repository ID cannot be empty");
          Validate.notNull(synchronizer, "The synchronizer parameter cannot be null");
          this.repositoryRootPath = repositoryRootPath;
          this.repositoryId = repositoryId;
          this.synchronizer = synchronizer;
          createRepositoryFilesIfNotExist();
      }
  
      /** @return the total number of entities residing in this particular repository (partition) */
      public Long countAllEntities() {
          return (long) new File(this.repositoryRootPath).list().length;
     }
 
     @Override
     public <V extends T> Iterator<V> iterateAllEntitiesSpecifiedBy(final Specification<V> specification) {
         Validate.notNull(specification, "Specification parameter cannot be null");
         return callExclusivelyWithRetry(new IterateAllEntitiesSpecifiedBy<V>(specification));
     }
 
     @Override
     public <V extends T> Collection<V> findAllEntitiesSpecifiedBy(final Specification<V> specification) {
         Validate.notNull(specification, "Specification parameter cannot be null");
         return callExclusivelyWithRetry(new FindAllEntitiesSpecifiedBy<V>(specification));
     }
 
     @Override
     public <V extends T> void put(final V entity) {
         callExclusivelyWithRetry(new Put<V>(entity));
     }
 
     @Override
     public <V extends T> Long removeAllEntitiesSpecifiedBy(final Specification<V> specification) {
         Validate.notNull(specification, "Specification parameter cannot be null");
         return callExclusivelyWithRetry(new RemoveAllEntitiesSpecifiedBy<V>(specification));
     }
 
     @Override
     public <V extends T> Boolean remove(final V entity) {
         if (entity == null) {
             return FALSE;
         }
         return callExclusivelyWithRetry(new Remove<V>(entity));
     }
 
     @Override
     public PersistenceDefinition getPersistenceDefinition() {
         return FILE;
     }
 
     @Override
     public String getFormat() {
         return "XStream XML";
     }
 
     @Override
     public void load() {
         log.warn("load() is only applicable for repositories with asynchronous persistence [PersistenceDefinition.INMEMORY_AND_*]");
     }
 
     @Override
     public void persist() {
         log.warn("persist() is only applicable for repositories with asynchronous persistence [PersistenceDefinition.INMEMORY_AND_*]");
     }
 
     @Override
     public <V extends T> void update(V entity) {
         put(entity);
     }
 
     @Override
     public EntityMetaData getMetaDataFor(final T entity) {
         PersistentEntity<T> persistentEntity = null;
         final PersistenceStrategy persistenceStrategy = new EntityId_NamedXStreamFilePersistenceStrategy(getRepositoryDirectory());
         final Set<PersistentEntity<T>> persistedEntitySet = new XmlSet(persistenceStrategy);
         for (final PersistentEntity<T> persistentEntityFound : persistedEntitySet) {
             final Entity entityFound = persistentEntityFound.getEntity();
             if (entity.equals(entityFound)) {
                 persistentEntity = persistentEntityFound;
                 break;
             }
         }
         return persistentEntity == null ? null : persistentEntity.getMetaData();
     }
 
     @Override
     public void close() {}
 }