/*
    * 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.util.Collection;
  import java.util.Iterator;
  import java.util.concurrent.Callable;
  
  import static org.apache.commons.lang.SystemUtils.FILE_SEPARATOR;
  import org.apache.commons.lang.Validate;
  import org.apache.commons.lang.NotImplementedException;
  
  import net.sourceforge.domian.entity.Entity;
  import net.sourceforge.domian.repository.HumanReadableFormatRepository;
  import net.sourceforge.domian.repository.InMemoryRepository;
  import net.sourceforge.domian.repository.PersistenceDefinition;
  import static net.sourceforge.domian.repository.PersistenceDefinition.INMEMORY_AND_FILE;
  import net.sourceforge.domian.specification.Specification;
  import net.sourceforge.domian.util.concurrent.locks.SemaphoreSynchronizer;
  import net.sourceforge.domian.util.concurrent.locks.Synchronizer;
  
  
  /**
   * An in-memory repository with persistence capabilities.
   * The persistence part is backed by <a href="http://xstream.codehaus.org">XStream</a> functionality.
   * <p/>
   * The only persistence definition supported by this repository is {@code PersistenceDefinition.INMEMORY_AND_FILE}.
   * All entities in this repository are persisted into <i>one single file</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>
   *
   * @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#INMEMORY_AND_FILE"><code>PersistenceDefinition.INMEMORY_AND_FILE</code></a>
   * @since 0.4
   */
  public class InMemoryAndXStreamXmlFileRepository<T extends Entity> extends AbstractXStreamSingleXmlFileRepository<T> implements HumanReadableFormatRepository<T> {
  
      protected static final String DEFAULT_REPOSITORY_ROOT_FILE_NAME = "inmemory-and-xstream-xml-file-repository";
      protected static final String DEFAULT_REPOSITORY_ROOT_DIR_NAME = "." + DEFAULT_REPOSITORY_ROOT_FILE_NAME;
      protected static final String DEFAULT_REPOSITORY_ROOT_PATH = DEFAULT_DOMIAN_ROOT_PATH + FILE_SEPARATOR + DEFAULT_REPOSITORY_ROOT_DIR_NAME;
  
      /** The repository delegate dealing with the in-memory stuff. */
      protected InMemoryRepository<T> inMemoryRepositoryDelegate;
  
      public InMemoryAndXStreamXmlFileRepository(final String repositoryId) {
          this(DEFAULT_REPOSITORY_ROOT_PATH, repositoryId);
      }
  
      public InMemoryAndXStreamXmlFileRepository(final String repositoryRootPath, final String repositoryId) {
          this(repositoryRootPath, repositoryId, new SemaphoreSynchronizer());
      }
  
      public InMemoryAndXStreamXmlFileRepository(final String repositoryId, final Synchronizer synchronizer) {
          this(DEFAULT_REPOSITORY_ROOT_PATH, repositoryId, synchronizer);
      }
  
      public InMemoryAndXStreamXmlFileRepository(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.inMemoryRepositoryDelegate = new InMemoryRepository<T>();
          this.synchronizer = synchronizer;
          createRepositoryRootPathIfNotExist();
          //load(); // Hesitant of doing this in constructor, too many side-effects
      }
  
      @Override
      protected String getRepositoryTypeName() {
          return DEFAULT_REPOSITORY_ROOT_FILE_NAME;
      }
  
      @Override
      public <V extends T> Iterator<V> iterateAllEntitiesSpecifiedBy(final Specification<V> specification) {
          Validate.notNull(specification, "Specification parameter cannot be null");
          return callConcurrently(new Callable<Iterator<V>>() {
              @Override
             public Iterator<V> call() {
                 return inMemoryRepositoryDelegate.iterateAllEntitiesSpecifiedBy(specification);
             }
         });
     }
 
     @Override
     public <V extends T> Collection<V> findAllEntitiesSpecifiedBy(final Specification<V> specification) {
         Validate.notNull(specification, "Specification parameter cannot be null");
         return callConcurrently(new Callable<Collection<V>>() {
             @Override
             public Collection<V> call() {
                 return inMemoryRepositoryDelegate.findAllEntitiesSpecifiedBy(specification);
             }
         });
     }
 
     @Override
     public <V extends T> void put(final V entity) {
         callConcurrently(new Callable<Void>() {
             @Override
             public Void call() {
                 inMemoryRepositoryDelegate.put(entity);
                 return null;
             }
         });
     }
 
     @Override
     public <V extends T> void update(V entity) {}
 
     @Override
     public <V extends T> Long removeAllEntitiesSpecifiedBy(final Specification<V> specification) {
         Validate.notNull(specification, "Specification parameter cannot be null");
         return callConcurrently(new Callable<Long>() {
             @Override
             public Long call() {
                 return inMemoryRepositoryDelegate.removeAllEntitiesSpecifiedBy(specification);
             }
         });
     }
 
     @Override
     public <V extends T> Boolean remove(final V entity) {
         return callConcurrently(new Callable<Boolean>() {
             @Override
             public Boolean call() {
                 return inMemoryRepositoryDelegate.remove(entity);
             }
         });
     }
 
     @Override
     public PersistenceDefinition getPersistenceDefinition() {
         return INMEMORY_AND_FILE;
     }
 
     @Override
     public String getFormat() {
         return "XStream XML";
     }
 
     @Override
     public void load() {
         callExclusivelyWithRetry(new Load(this));
     }
 
     @Override
     public void persist() {
         callExclusivelyWithRetry(new Persist(this));
     }
 
     @Override
     public void close() {}
 }