/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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 org.apache.commons.vfs2.impl;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.vfs2.Capability;
  import org.apache.commons.vfs2.FileName;
  import org.apache.commons.vfs2.FileObject;
  import org.apache.commons.vfs2.FileSystemException;
  import org.apache.commons.vfs2.FileSystemOptions;
  import org.apache.commons.vfs2.FileType;
  import org.apache.commons.vfs2.NameScope;
  import org.apache.commons.vfs2.provider.AbstractFileName;
  import org.apache.commons.vfs2.provider.AbstractFileSystem;
  import org.apache.commons.vfs2.provider.DelegateFileObject;
  
  /**
   * A logical file system, made up of set of junctions, or links, to files from other file systems.
   * <p>
   * TODO - Handle nested junctions.
   * </p>
   */
  public class VirtualFileSystem extends AbstractFileSystem {
  
      private final Map<FileName, FileObject> junctions = new HashMap<>();
  
      /**
       * Constructs a new instance.
       *
       * @param rootFileName The root file name of this file system.
       * @param fileSystemOptions Options to build this file system.
       */
      public VirtualFileSystem(final AbstractFileName rootFileName, final FileSystemOptions fileSystemOptions) {
          super(rootFileName, null, fileSystemOptions);
      }
  
      /**
       * Adds the capabilities of this file system.
       */
      @Override
      protected void addCapabilities(final Collection<Capability> caps) {
          // TODO - this isn't really true
          caps.add(Capability.ATTRIBUTES);
          caps.add(Capability.CREATE);
          caps.add(Capability.DELETE);
          caps.add(Capability.GET_TYPE);
          caps.add(Capability.JUNCTIONS);
          caps.add(Capability.GET_LAST_MODIFIED);
          caps.add(Capability.SET_LAST_MODIFIED_FILE);
          caps.add(Capability.SET_LAST_MODIFIED_FOLDER);
          caps.add(Capability.LIST_CHILDREN);
          caps.add(Capability.READ_CONTENT);
          caps.add(Capability.SIGNING);
          caps.add(Capability.WRITE_CONTENT);
          caps.add(Capability.APPEND_CONTENT);
      }
  
      /**
       * Adds a junction to this file system.
       *
       * @param junctionPoint The location of the junction.
       * @param targetFile The target file to base the junction on.
       * @throws FileSystemException if an error occurs.
       */
      @Override
      public void addJunction(final String junctionPoint, final FileObject targetFile) throws FileSystemException {
          final FileName junctionName = getFileSystemManager().resolveName(getRootName(), junctionPoint);
  
          // Check for nested junction - these are not supported yet
          if (getJunctionForFile(junctionName) != null) {
              throw new FileSystemException("vfs.impl/nested-junction.error", junctionName);
          }
  
          try {
              // Add to junction table
              junctions.put(junctionName, targetFile);
  
              // Attach to file
              final DelegateFileObject junctionFile = (DelegateFileObject) getFileFromCache(junctionName);
              if (junctionFile != null) {
                  junctionFile.setFile(targetFile);
              }
 
             // Create ancestors of junction point
             FileName childName = junctionName;
             boolean done = false;
             for (AbstractFileName parentName = (AbstractFileName) childName.getParent(); !done
                     && parentName != null; childName = parentName, parentName = (AbstractFileName) parentName
                             .getParent()) {
                 DelegateFileObject file = (DelegateFileObject) getFileFromCache(parentName);
                 if (file == null) {
                     file = new DelegateFileObject(parentName, this, null);
                     putFileToCache(file);
                 } else {
                     done = file.exists();
                 }
 
                 // As this is the parent of our junction it has to be a folder
                 file.attachChild(childName, FileType.FOLDER);
             }
 
             // TODO - attach all cached children of the junction point to their real file
         } catch (final Exception e) {
             throw new FileSystemException("vfs.impl/create-junction.error", junctionName, e);
         }
     }
 
     @Override
     public void close() {
         super.close();
         junctions.clear();
     }
 
     /**
      * Creates a file object. This method is called only if the requested file is not cached.
      */
     @Override
     protected FileObject createFile(final AbstractFileName name) throws Exception {
         // Find the file that the name points to
         final FileName junctionPoint = getJunctionForFile(name);
         final FileObject file;
         if (junctionPoint != null) {
             // Resolve the real file
             final FileObject junctionFile = junctions.get(junctionPoint);
             final String relName = junctionPoint.getRelativeName(name);
             file = junctionFile.resolveFile(relName, NameScope.DESCENDENT_OR_SELF);
         } else {
             file = null;
         }
 
         // Return a wrapper around the file
         return new DelegateFileObject(name, this, file);
     }
 
     /**
      * Locates the junction point for the junction containing the given file.
      *
      * @param name The FileName.
      * @return the FileName where the junction occurs.
      */
     private FileName getJunctionForFile(final FileName name) {
         if (junctions.containsKey(name)) {
             // The name points to the junction point directly
             return name;
         }
         // Find matching junction
         return junctions.keySet().stream().filter(fileName -> fileName.isDescendent(name)).findFirst().orElse(null);
     }
 
     /**
      * Removes a junction from this file system.
      *
      * @param junctionPoint The junction to remove.
      * @throws FileSystemException if an error occurs.
      */
     @Override
     public void removeJunction(final String junctionPoint) throws FileSystemException {
         final FileName junctionName = getFileSystemManager().resolveName(getRootName(), junctionPoint);
         junctions.remove(junctionName);
 
         // TODO - remove from parents of junction point
         // TODO - detach all cached children of the junction point from their real file
     }
 }