sched/src/com/android/sched/vfs/CaseInsensitiveFS.java - toolchain/jack - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * 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 com.android.sched.vfs;

 import com.google.common.base.Splitter;

 import com.android.sched.util.config.HasKeyId;
 import com.android.sched.util.config.MessageDigestFactory;
 import com.android.sched.util.config.ThreadConfig;
 import com.android.sched.util.config.expression.LongExpression;
 import com.android.sched.util.config.id.BooleanPropertyId;
 import com.android.sched.util.config.id.IntegerPropertyId;
 import com.android.sched.util.config.id.MessageDigestPropertyId;
 import com.android.sched.util.file.CannotCloseException;
 import com.android.sched.util.file.CannotCreateFileException;
 import com.android.sched.util.file.CannotDeleteFileException;
 import com.android.sched.util.file.CannotGetModificationTimeException;
 import com.android.sched.util.file.NoSuchFileException;
 import com.android.sched.util.file.NotDirectoryException;
 import com.android.sched.util.file.NotFileException;
 import com.android.sched.util.file.Statusful;
 import com.android.sched.util.file.StreamFileStatus;
 import com.android.sched.util.file.WrongPermissionException;
 import com.android.sched.util.location.ColumnAndLineLocation;
 import com.android.sched.util.location.Location;
 import com.android.sched.vfs.CaseInsensitiveFS.CaseInsensitiveVDir;
 import com.android.sched.vfs.CaseInsensitiveFS.CaseInsensitiveVFile;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.LineNumberReader;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.nio.file.attribute.FileTime;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Iterator;
 import java.util.Set;

 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnegative;
 import javax.annotation.Nonnull;

 /**
  * A filter implementation of a {@link VFS} which take a {@link VFS}, case insensitive or not, and
  * store in it files and directories with their name encoded through a digest algorithm. With that
  * filter, even if the real {@link VFS} is case insensitive, the filtered {@link VFS} acts as a case
  * sensitive {@link VFS}.
  */
 @HasKeyId
 public class CaseInsensitiveFS extends BaseVFS<CaseInsensitiveVDir, CaseInsensitiveVFile> implements
     VFS, Statusful {
   static final String INDEX_NAME = "index";
   static final String DEBUG_NAME = "index.dbg";

   public static final IntegerPropertyId NB_GROUP = IntegerPropertyId
       .create("sched.vfs.case-insensitive.group.count",
           "Number of directory used to encode a path name").withMin(0).addDefaultValue(1);

   public static final IntegerPropertyId SZ_GROUP = IntegerPropertyId
       .create("sched.vfs.case-insensitive.group.size",
           "Number of letters in directory name used to encode a path name")
       .requiredIf(NB_GROUP.getValue().isGreater(LongExpression.getConstant(0))).withMin(0)
       .addDefaultValue(2);

   @Nonnull
   public static final MessageDigestPropertyId ALGO = MessageDigestPropertyId.create(
       "sched.vfs.case-insensitive.algo", "Algorithm used to encode a path name").addDefaultValue(
       "SHA");

   @Nonnull
   public static final BooleanPropertyId DEBUG = BooleanPropertyId.create(
       "sched.vfs.case-insensitive.debug",
       "generate an index file '" + DEBUG_NAME + "' for debugging purpose").addDefaultValue(false);

   @Nonnull
   private static final char INDEX_SEPARATOR = '/';

   @Nonnull
   private static final Splitter splitter = Splitter.on(INDEX_SEPARATOR);

   @Nonnegative
   private final int numGroups;
   @Nonnegative
   private final int groupSize;
   @Nonnull
   private final MessageDigestFactory mdf;
   private final boolean debug;

   @Nonnull
   private final CaseInsensitiveVDir root = new CaseInsensitiveVDir(this, null, "");

   @Nonnull
   private final Set<Capabilities> capabilities;

   @Override
   @Nonnull
   public String getDescription() {
     return "case insensitive wrapper";
   }

   static class CaseInsensitiveVDir extends InMemoryVDir {
     @CheckForNull
     protected final VDir parent;

     CaseInsensitiveVDir(
         @Nonnull BaseVFS<? extends InMemoryVDir, ? extends CaseInsensitiveVFile> vfs,
         @CheckForNull VDir parent, @Nonnull String name) {
       super(vfs, name);
       this.parent = parent;
     }

     @Override
     @Nonnull
     public VPath getPath() {
       if (parent != null) {
         return parent.getPath().clone().appendPath(new VPath(name, '/'));
       } else {
         return VPath.ROOT;
       }
     }

     @Override
     @Nonnull
     public BaseVFile getVFile(@Nonnull String name) throws NoSuchFileException,
         NotFileException {
       return vfs.getVFile(this, name);
     }

     @Override
     @Nonnull
     public BaseVDir getVDir(@Nonnull String name) throws NotDirectoryException,
         NoSuchFileException {
       return vfs.getVDir(this, name);
     }

     @Override
     @Nonnull
     public BaseVFile createVFile(@Nonnull String name) throws CannotCreateFileException {
       return vfs.createVFile(this, name);
     }

     @Override
     @Nonnull
     public BaseVDir createVDir(@Nonnull String name) throws CannotCreateFileException {
       return vfs.createVDir(this, name);
     }

     @Override
     @Nonnull
     public Collection<? extends BaseVElement> list() {
       return vfs.list(this);
     }

     @CheckForNull
     public VDir getParent() {
       return parent;
     }
   }

   static class CaseInsensitiveVFile extends ParentVFile {
     @CheckForNull
     private BaseVFile encodedFile;

     CaseInsensitiveVFile(
         @Nonnull BaseVFS<? extends InMemoryVDir, ? extends CaseInsensitiveVFile> vfs,
         @Nonnull VDir parent, @Nonnull String name) {
       super(vfs, parent, name);
     }

     private void setEncodedFile(@Nonnull BaseVFile encodedFile) {
       this.encodedFile = encodedFile;
     }

     @CheckForNull
     private BaseVFile getEncodedFile() {
       return encodedFile;
     }

     @Override
     public void delete() throws CannotDeleteFileException {
       vfs.delete(this);
     }

     private void deleteFromCache() {
       ((InMemoryVDir) parent).internalDelete(name);
     }
   }

   @Nonnull
   private final BaseVFS<BaseVDir, BaseVFile> vfs;

   private boolean used = false;

   public CaseInsensitiveFS(@Nonnull VFS vfs) throws BadVFSFormatException {
     this(vfs, ThreadConfig.get(NB_GROUP).intValue(), ThreadConfig.get(SZ_GROUP).intValue(),
         ThreadConfig.get(ALGO), ThreadConfig.get(DEBUG).booleanValue());
   }

   @SuppressWarnings("unchecked")
   public CaseInsensitiveFS(@Nonnull VFS vfs, int numGroups, int groupSize,
       @Nonnull MessageDigestFactory mdf, boolean debug)
       throws BadVFSFormatException {
     this.vfs = (BaseVFS<BaseVDir, BaseVFile>) vfs;

     Set<Capabilities> capabilities = EnumSet.copyOf(vfs.getCapabilities());
     capabilities.add(Capabilities.CASE_SENSITIVE);
     capabilities.add(Capabilities.UNIQUE_ELEMENT);
     this.capabilities = Collections.unmodifiableSet(capabilities);

     this.numGroups = numGroups;
     this.groupSize = groupSize;
     this.mdf = mdf;
     this.debug = debug;

     initVFS();
   }

   private void initVFS() throws BadVFSFormatException {
     LineNumberReader reader = null;
     VFile file = null;
     try {
       try {
         file = vfs.getRootDir().getVFile(INDEX_NAME);
       } catch (NoSuchFileException e) {
         if (!vfs.getRootDir().isEmpty()) {
           // If VFS is not empty, index file is missing
           throw new BadVFSFormatException(this, vfs.getLocation(), e);
         }

         return;
       } catch (NotFileException e) {
         throw new BadVFSFormatException(this, vfs.getLocation(), e);
       }

       try {
         reader = new LineNumberReader(new InputStreamReader(file.getInputStream()));
       } catch (WrongPermissionException e) {
         throw new BadVFSFormatException(this, vfs.getLocation(), e);
       }

       String line;
       try {
         while ((line = reader.readLine()) != null) {
           if (line.charAt(1) != ':') {
             throw new BadVFSFormatException(this, vfs.getLocation(),
                 new WrongFileFormatException(new ColumnAndLineLocation(file.getLocation(),
                     reader.getLineNumber())));
           }

           char type = line.charAt(0);
           switch (type) {
             case 'd':
               loadVDir(line.substring(2));
               break;
             case 'f':
               loadVFile(line.substring(2));
               break;
             default:
               throw new BadVFSFormatException(this, vfs.getLocation(),
                   new WrongFileFormatException(new ColumnAndLineLocation(file.getLocation(),
                       reader.getLineNumber())));
           }
         }
       } catch (NotDirectoryException | NotFileException e) {
         throw new BadVFSFormatException(this, vfs.getLocation(), e);
       } catch (IOException e) {
         throw new BadVFSFormatException(this, vfs.getLocation(), e);
       }
     } finally {
       if (reader != null) {
         assert file != null;

         try {
           reader.close();
         } catch (IOException e) {
           // Ignore
         }
       }
     }
   }

   private void loadVDir(@Nonnull String path) throws NotDirectoryException {
     CaseInsensitiveVDir currentDir = getRootDir();
     Iterator<String> pathElementIterator = splitter.split(path).iterator();
     String pathElement = null;
     while (pathElementIterator.hasNext()) {
       pathElement = pathElementIterator.next();
       assert !pathElement.isEmpty();
       currentDir = loadVDir(currentDir, pathElement);
     }
   }

   private void loadVFile(@Nonnull String path)
       throws NotDirectoryException, NotFileException {
     CaseInsensitiveVDir currentDir = getRootDir();
     Iterator<String> pathElementIterator = splitter.split(path).iterator();
     String pathElement = null;
     while (pathElementIterator.hasNext()) {
       pathElement = pathElementIterator.next();
       assert !pathElement.isEmpty();
       if (pathElementIterator.hasNext()) {
         // simpleName is a dir name
         currentDir = loadVDir(currentDir, pathElement);
       }
     }
     loadVFile(currentDir, pathElement);
   }

   @Override
   @Nonnull
   public Set<Capabilities> getCapabilities() {
     return capabilities;
   }

   @Override
   @Nonnull
   public Location getLocation() {
     return vfs.getLocation();
   }

   @Override
   @Nonnull
   public String getPath() {
     return vfs.getPath();
   }

   @Override
   @Nonnull
   public CaseInsensitiveVDir getRootDir() {
     used = true;

     return root;
   }

   @Override
   public synchronized void close() throws CannotCloseException {
     if (!closed) {
       try {
         PrintStream printer =
             new PrintStream(vfs.getRootDir().createVFile(INDEX_NAME).getOutputStream());

         printIndex(printer, getRootDir());
         printer.flush();
         printer.close();

         if (debug) {
           printer = new PrintStream(vfs.getRootDir().createVFile(DEBUG_NAME).getOutputStream());

           printDebug(printer, getRootDir());
           printer.flush();
           printer.close();
         }
       } catch (WrongPermissionException | CannotCreateFileException e) {
         throw new CannotCloseException(this, e);
       }

       vfs.close();
       closed = true;
     }
   }

   private void printIndex(@Nonnull PrintStream printer, @Nonnull InMemoryVDir dir) {
     Collection<? extends BaseVElement> elements = dir.list();
     if (elements.size() > 0) {
       for (BaseVElement element : elements) {
         if (element.isVDir()) {
           printIndex(printer, (InMemoryVDir) element);
         } else {
           CaseInsensitiveVFile file = (CaseInsensitiveVFile) element;

           printer.print("f:");
           printer.print(file.getPath().getPathAsString(INDEX_SEPARATOR));
           printer.println();
         }
       }
     } else {
       printer.print("d:");
       printer.print(dir.getPath().getPathAsString(INDEX_SEPARATOR));
       printer.println();
     }
   }

   private void printDebug(@Nonnull PrintStream printer, @Nonnull InMemoryVDir dir) {
     Collection<? extends BaseVElement> elements = dir.list();

     printer.print("d:");
     printer.print(dir.getPath().getPathAsString(File.separatorChar));
     printer.println();

     for (BaseVElement element : elements) {
       if (element.isVDir()) {
         printDebug(printer, (InMemoryVDir) element);
       } else {
         CaseInsensitiveVFile file = (CaseInsensitiveVFile) element;

         printer.print("f:");
         printer.print(loadAndGetEncodedFile(file).getPath().getPathAsString(File.separatorChar));
         printer.print(":");
         printer.print(file.getPath().getPathAsString(File.separatorChar));
         printer.println();
       }
     }
   }

   //
   // Stream
   //

   @Nonnull
   private BaseVFile loadAndGetEncodedFile(@Nonnull CaseInsensitiveVFile file) {

     BaseVFile encodedFile = file.getEncodedFile();
     if (encodedFile == null) {
       try {
         encodedFile = vfs.getRootDir().getVFile(encode(file.getPath()));
         file.setEncodedFile(encodedFile);
       } catch (NotDirectoryException | NotFileException | NoSuchFileException e) {
         throw new RuntimeBadVFSFormatException(vfs, vfs.getLocation(), e);
       }
     }
     return encodedFile;
   }

   @Override
   @Nonnull
   InputStream openRead(@Nonnull CaseInsensitiveVFile file) throws WrongPermissionException {
     assert !isClosed();

     return loadAndGetEncodedFile(file).getInputStream();
   }

   @Override
   @Nonnull
   OutputStream openWrite(@Nonnull CaseInsensitiveVFile file) throws WrongPermissionException {
     return openWrite(file, false);
   }

   @Override
   @Nonnull
   OutputStream openWrite(@Nonnull CaseInsensitiveVFile file, boolean append)
       throws WrongPermissionException {
     assert !isClosed();

     return loadAndGetEncodedFile(file).getOutputStream(append);
   }

   //
   // VElement
   //

   @Override
   @Nonnull
   CaseInsensitiveVDir getVDir(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
       throws NotDirectoryException, NoSuchFileException {
     CaseInsensitiveVDir vDir = getVDirFromCache(parent, name);
     if (vDir != null) {
       return vDir;
     } else {
       throw new NoSuchFileException(getVDirLocation(parent, name));
     }
   }

   @Override
   @Nonnull
   CaseInsensitiveVFile getVFile(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
       throws NotFileException, NoSuchFileException {
     CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
     if (vFile != null) {
       return vFile;
     } else {
       throw new NoSuchFileException(getVFileLocation(parent, name));
     }
   }

   @CheckForNull
   CaseInsensitiveVFile getVFileFromCache(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
       throws NotFileException {
     BaseVElement element = parent.getFromCache(name);
     if (element == null) {
       return null;
     } else if (!element.isVDir()) {
       return (CaseInsensitiveVFile) element;
     } else {
       throw new NotFileException(getVFileLocation(parent, name));
     }
   }

   @CheckForNull
   CaseInsensitiveVDir getVDirFromCache(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
       throws NotDirectoryException {
     BaseVElement element = parent.getFromCache(name);
     if (element == null) {
       return null;
     } else if (element.isVDir()) {
       return (CaseInsensitiveVDir) element;
     } else {
       throw new NotDirectoryException(getVDirLocation(parent, name));
     }
   }

   @Override
   @Nonnull
   CaseInsensitiveVDir createVDir(@Nonnull CaseInsensitiveVDir parent,
       @Nonnull String name) throws CannotCreateFileException {
     assert !isClosed();

     try {
       return loadVDir(parent, name);
     } catch (NotDirectoryException e) {
       throw new CannotCreateFileException(getVDirLocation(parent, name));
     }
   }

   @Override
   @Nonnull
   synchronized CaseInsensitiveVFile createVFile(
       @Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws CannotCreateFileException {
     assert !isClosed();
     try {
       CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
       if (vFile != null) {
         return vFile;
       } else {
         CaseInsensitiveVFile original = new CaseInsensitiveVFile(this, parent, name);
         BaseVFile encoded = vfs.getRootDir().createVFile(encode(original.getPath()));
         original.setEncodedFile(encoded);
         parent.putInCache(name, original);

         return original;
       }
     } catch (NotFileException e) {
       throw new CannotCreateFileException(getVFileLocation(parent, name));
     }
   }

   @Nonnull
   synchronized CaseInsensitiveVDir loadVDir(
       @Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws NotDirectoryException {
     assert !isClosed();

     CaseInsensitiveVDir vDir = getVDirFromCache(parent, name);
     if (vDir != null) {
       return vDir;
     } else {
       CaseInsensitiveVDir dir = new CaseInsensitiveVDir(this, parent, name);
       parent.putInCache(name, dir);
       return dir;
     }
   }

   @Nonnull
   synchronized CaseInsensitiveVFile loadVFile(
       @Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws NotFileException {
     assert !isClosed();
     CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
     if (vFile != null) {
       return vFile;
     } else {
       CaseInsensitiveVFile original = new CaseInsensitiveVFile(this, parent, name);
       parent.putInCache(name, original);

       return original;
     }
   }

   @Override
   @Nonnull
   void delete(@Nonnull CaseInsensitiveVFile file) throws CannotDeleteFileException {
     assert !isClosed();

     try {
       BaseVFile encoded = vfs.getRootDir().getVFile(encode(file.getPath()));
       vfs.delete(encoded);
       file.deleteFromCache();
     } catch (NotDirectoryException e) {
       throw new CannotDeleteFileException(file);
     } catch (NotFileException e) {
       throw new CannotDeleteFileException(file);
     } catch (NoSuchFileException e) {
       throw new CannotDeleteFileException(file);
     }
   }

   @Override
   @Nonnull
   Collection<? extends BaseVElement> list(@Nonnull CaseInsensitiveVDir dir) {
     return dir.getAllFromCache();
   }

   @Override
   boolean isEmpty(@Nonnull CaseInsensitiveVDir dir) {
     return dir.isEmpty();
   }

   @Override
   @Nonnull
   public FileTime getLastModified(@Nonnull CaseInsensitiveVFile file)
       throws CannotGetModificationTimeException {
     return vfs.getLastModified(loadAndGetEncodedFile(file));
   }

   //
   // Location
   //

   @Override
   @Nonnull
   Location getVFileLocation(@Nonnull CaseInsensitiveVFile file) {
     return vfs.getVFileLocation(loadAndGetEncodedFile(file));
   }

   @Override
   @Nonnull
   Location getVFileLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) {
     return vfs.getRootDir().getVFileLocation(
         encode(parent.getPath().clone().appendPath(new VPath(name, '/'))));
   }

   @Override
   @Nonnull
   Location getVDirLocation(@Nonnull CaseInsensitiveVDir dir) {
     return vfs.getRootDir().getVDirLocation(encode(dir.getPath()));
   }

   @Override
   @Nonnull
   Location getVDirLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) {
     return vfs.getRootDir().getVDirLocation(
         encode(parent.getPath().clone().appendPath(new VPath(name, '/'))));
   }

   @Override
   @Nonnull
   Location getVFileLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull VPath path) {
     return vfs.getRootDir().getVFileLocation(encode(parent.getPath().clone().appendPath(path)));
   }

   @Override
   @Nonnull
   Location getVDirLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull VPath path) {
     return vfs.getRootDir().getVDirLocation(encode(parent.getPath().clone().appendPath(path)));
   }

   //
   // Misc
   //

   @Override
   public boolean needsSequentialWriting() {
     return vfs.needsSequentialWriting();
   }

   //
   // Encode / Decode
   //

   @Nonnull
   private VPath encode(@Nonnull VPath path) {
     char[] digest = encode(mdf.create().digest(path.getPathAsString('/').getBytes()));

     StringBuilder sb = new StringBuilder();
     int idx = 0;
     try {
       for (int groupIdx = 0; groupIdx < numGroups; groupIdx++) {
         for (int letterIdx = 0; letterIdx < groupSize; letterIdx++) {
           sb.append(digest[idx++]);
         }
         sb.append('/');
       }

       if (idx < digest.length) {
         sb.append(digest, idx, digest.length - idx);
       } else {
         // Remove the last /, it is not a directory here
         sb.setLength(sb.length() - 1);
       }
     } catch (IndexOutOfBoundsException e) {
     }


     return new VPath(sb.toString(), '/');
   }

   @Nonnull
   private static final byte[] code = "0123456789ABCDEF".getBytes();

   @Nonnull
   static char[] encode(@Nonnull byte[] bytes) {
     char[] array = new char[bytes.length * 2];

     for (int idx = 0; idx < bytes.length; idx++) {
       array[(idx << 1)] = (char) code[(bytes[idx] & 0xF0) >> 4];
       array[(idx << 1) + 1] = (char) code[(bytes[idx] & 0x0F)];
     }

     return array;
   }

   @Override
   @Nonnull
   VPath getPathFromDir(@Nonnull CaseInsensitiveVDir parent, @Nonnull CaseInsensitiveVFile file) {
     StringBuilder path = getPathFromDirInternal(parent, (CaseInsensitiveVDir) file.getParent())
         .append(file.getName());
     return new VPath(path.toString(), '/');
   }

   @Nonnull
   private StringBuilder getPathFromDirInternal(@Nonnull CaseInsensitiveVDir baseDir,
       @Nonnull CaseInsensitiveVDir currentDir) {
     if (baseDir == currentDir) {
       return new StringBuilder();
     }
     CaseInsensitiveVDir currentParent = (CaseInsensitiveVDir) currentDir.getParent();
     assert currentParent != null;
     return getPathFromDirInternal(baseDir, currentParent).append(currentDir.getName()).append('/');
   }

   @Override
   @Nonnull
   VPath getPathFromRoot(@Nonnull CaseInsensitiveVFile file) {
     return getPathFromDir(root, file);
   }

   @Override
   @Nonnull
   public StreamFileStatus getStatus() {
     if (!used) {
       return StreamFileStatus.NOT_USED;
     } else if (closed) {
       return StreamFileStatus.CLOSED;
     } else {
       return StreamFileStatus.OPEN;
     }
   }

   @Override
   @CheckForNull
   public String getInfoString() {
     return vfs.getInfoString();
   }

   @Override
   public String toString() {
     return "ciFS >> " + vfs.toString();
   }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* 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 com.android.sched.vfs;

	import com.google.common.base.Splitter;

	import com.android.sched.util.config.HasKeyId;
	import com.android.sched.util.config.MessageDigestFactory;
	import com.android.sched.util.config.ThreadConfig;
	import com.android.sched.util.config.expression.LongExpression;
	import com.android.sched.util.config.id.BooleanPropertyId;
	import com.android.sched.util.config.id.IntegerPropertyId;
	import com.android.sched.util.config.id.MessageDigestPropertyId;
	import com.android.sched.util.file.CannotCloseException;
	import com.android.sched.util.file.CannotCreateFileException;
	import com.android.sched.util.file.CannotDeleteFileException;
	import com.android.sched.util.file.CannotGetModificationTimeException;
	import com.android.sched.util.file.NoSuchFileException;
	import com.android.sched.util.file.NotDirectoryException;
	import com.android.sched.util.file.NotFileException;
	import com.android.sched.util.file.Statusful;
	import com.android.sched.util.file.StreamFileStatus;
	import com.android.sched.util.file.WrongPermissionException;
	import com.android.sched.util.location.ColumnAndLineLocation;
	import com.android.sched.util.location.Location;
	import com.android.sched.vfs.CaseInsensitiveFS.CaseInsensitiveVDir;
	import com.android.sched.vfs.CaseInsensitiveFS.CaseInsensitiveVFile;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.LineNumberReader;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.nio.file.attribute.FileTime;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.EnumSet;
	import java.util.Iterator;
	import java.util.Set;

	import javax.annotation.CheckForNull;
	import javax.annotation.Nonnegative;
	import javax.annotation.Nonnull;

	/**
	* A filter implementation of a {@link VFS} which take a {@link VFS}, case insensitive or not, and
	* store in it files and directories with their name encoded through a digest algorithm. With that
	* filter, even if the real {@link VFS} is case insensitive, the filtered {@link VFS} acts as a case
	* sensitive {@link VFS}.
	*/
	@HasKeyId
	public class CaseInsensitiveFS extends BaseVFS<CaseInsensitiveVDir, CaseInsensitiveVFile> implements
	VFS, Statusful {
	static final String INDEX_NAME = "index";
	static final String DEBUG_NAME = "index.dbg";

	public static final IntegerPropertyId NB_GROUP = IntegerPropertyId
	.create("sched.vfs.case-insensitive.group.count",
	"Number of directory used to encode a path name").withMin(0).addDefaultValue(1);

	public static final IntegerPropertyId SZ_GROUP = IntegerPropertyId
	.create("sched.vfs.case-insensitive.group.size",
	"Number of letters in directory name used to encode a path name")
	.requiredIf(NB_GROUP.getValue().isGreater(LongExpression.getConstant(0))).withMin(0)
	.addDefaultValue(2);

	@Nonnull
	public static final MessageDigestPropertyId ALGO = MessageDigestPropertyId.create(
	"sched.vfs.case-insensitive.algo", "Algorithm used to encode a path name").addDefaultValue(
	"SHA");

	@Nonnull
	public static final BooleanPropertyId DEBUG = BooleanPropertyId.create(
	"sched.vfs.case-insensitive.debug",
	"generate an index file '" + DEBUG_NAME + "' for debugging purpose").addDefaultValue(false);

	@Nonnull
	private static final char INDEX_SEPARATOR = '/';

	@Nonnull
	private static final Splitter splitter = Splitter.on(INDEX_SEPARATOR);

	@Nonnegative
	private final int numGroups;
	@Nonnegative
	private final int groupSize;
	@Nonnull
	private final MessageDigestFactory mdf;
	private final boolean debug;

	@Nonnull
	private final CaseInsensitiveVDir root = new CaseInsensitiveVDir(this, null, "");

	@Nonnull
	private final Set<Capabilities> capabilities;

	@Override
	@Nonnull
	public String getDescription() {
	return "case insensitive wrapper";
	}

	static class CaseInsensitiveVDir extends InMemoryVDir {
	@CheckForNull
	protected final VDir parent;

	CaseInsensitiveVDir(
	@Nonnull BaseVFS<? extends InMemoryVDir, ? extends CaseInsensitiveVFile> vfs,
	@CheckForNull VDir parent, @Nonnull String name) {
	super(vfs, name);
	this.parent = parent;
	}

	@Override
	@Nonnull
	public VPath getPath() {
	if (parent != null) {
	return parent.getPath().clone().appendPath(new VPath(name, '/'));
	} else {
	return VPath.ROOT;
	}
	}

	@Override
	@Nonnull
	public BaseVFile getVFile(@Nonnull String name) throws NoSuchFileException,
	NotFileException {
	return vfs.getVFile(this, name);
	}

	@Override
	@Nonnull
	public BaseVDir getVDir(@Nonnull String name) throws NotDirectoryException,
	NoSuchFileException {
	return vfs.getVDir(this, name);
	}

	@Override
	@Nonnull
	public BaseVFile createVFile(@Nonnull String name) throws CannotCreateFileException {
	return vfs.createVFile(this, name);
	}

	@Override
	@Nonnull
	public BaseVDir createVDir(@Nonnull String name) throws CannotCreateFileException {
	return vfs.createVDir(this, name);
	}

	@Override
	@Nonnull
	public Collection<? extends BaseVElement> list() {
	return vfs.list(this);
	}

	@CheckForNull
	public VDir getParent() {
	return parent;
	}
	}

	static class CaseInsensitiveVFile extends ParentVFile {
	@CheckForNull
	private BaseVFile encodedFile;

	CaseInsensitiveVFile(
	@Nonnull BaseVFS<? extends InMemoryVDir, ? extends CaseInsensitiveVFile> vfs,
	@Nonnull VDir parent, @Nonnull String name) {
	super(vfs, parent, name);
	}

	private void setEncodedFile(@Nonnull BaseVFile encodedFile) {
	this.encodedFile = encodedFile;
	}

	@CheckForNull
	private BaseVFile getEncodedFile() {
	return encodedFile;
	}

	@Override
	public void delete() throws CannotDeleteFileException {
	vfs.delete(this);
	}

	private void deleteFromCache() {
	((InMemoryVDir) parent).internalDelete(name);
	}
	}

	@Nonnull
	private final BaseVFS<BaseVDir, BaseVFile> vfs;

	private boolean used = false;

	public CaseInsensitiveFS(@Nonnull VFS vfs) throws BadVFSFormatException {
	this(vfs, ThreadConfig.get(NB_GROUP).intValue(), ThreadConfig.get(SZ_GROUP).intValue(),
	ThreadConfig.get(ALGO), ThreadConfig.get(DEBUG).booleanValue());
	}

	@SuppressWarnings("unchecked")
	public CaseInsensitiveFS(@Nonnull VFS vfs, int numGroups, int groupSize,
	@Nonnull MessageDigestFactory mdf, boolean debug)
	throws BadVFSFormatException {
	this.vfs = (BaseVFS<BaseVDir, BaseVFile>) vfs;

	Set<Capabilities> capabilities = EnumSet.copyOf(vfs.getCapabilities());
	capabilities.add(Capabilities.CASE_SENSITIVE);
	capabilities.add(Capabilities.UNIQUE_ELEMENT);
	this.capabilities = Collections.unmodifiableSet(capabilities);

	this.numGroups = numGroups;
	this.groupSize = groupSize;
	this.mdf = mdf;
	this.debug = debug;

	initVFS();
	}

	private void initVFS() throws BadVFSFormatException {
	LineNumberReader reader = null;
	VFile file = null;
	try {
	try {
	file = vfs.getRootDir().getVFile(INDEX_NAME);
	} catch (NoSuchFileException e) {
	if (!vfs.getRootDir().isEmpty()) {
	// If VFS is not empty, index file is missing
	throw new BadVFSFormatException(this, vfs.getLocation(), e);
	}

	return;
	} catch (NotFileException e) {
	throw new BadVFSFormatException(this, vfs.getLocation(), e);
	}

	try {
	reader = new LineNumberReader(new InputStreamReader(file.getInputStream()));
	} catch (WrongPermissionException e) {
	throw new BadVFSFormatException(this, vfs.getLocation(), e);
	}

	String line;
	try {
	while ((line = reader.readLine()) != null) {
	if (line.charAt(1) != ':') {
	throw new BadVFSFormatException(this, vfs.getLocation(),
	new WrongFileFormatException(new ColumnAndLineLocation(file.getLocation(),
	reader.getLineNumber())));
	}

	char type = line.charAt(0);
	switch (type) {
	case 'd':
	loadVDir(line.substring(2));
	break;
	case 'f':
	loadVFile(line.substring(2));
	break;
	default:
	throw new BadVFSFormatException(this, vfs.getLocation(),
	new WrongFileFormatException(new ColumnAndLineLocation(file.getLocation(),
	reader.getLineNumber())));
	}
	}
	} catch (NotDirectoryException \| NotFileException e) {
	throw new BadVFSFormatException(this, vfs.getLocation(), e);
	} catch (IOException e) {
	throw new BadVFSFormatException(this, vfs.getLocation(), e);
	}
	} finally {
	if (reader != null) {
	assert file != null;

	try {
	reader.close();
	} catch (IOException e) {
	// Ignore
	}
	}
	}
	}

	private void loadVDir(@Nonnull String path) throws NotDirectoryException {
	CaseInsensitiveVDir currentDir = getRootDir();
	Iterator<String> pathElementIterator = splitter.split(path).iterator();
	String pathElement = null;
	while (pathElementIterator.hasNext()) {
	pathElement = pathElementIterator.next();
	assert !pathElement.isEmpty();
	currentDir = loadVDir(currentDir, pathElement);
	}
	}

	private void loadVFile(@Nonnull String path)
	throws NotDirectoryException, NotFileException {
	CaseInsensitiveVDir currentDir = getRootDir();
	Iterator<String> pathElementIterator = splitter.split(path).iterator();
	String pathElement = null;
	while (pathElementIterator.hasNext()) {
	pathElement = pathElementIterator.next();
	assert !pathElement.isEmpty();
	if (pathElementIterator.hasNext()) {
	// simpleName is a dir name
	currentDir = loadVDir(currentDir, pathElement);
	}
	}
	loadVFile(currentDir, pathElement);
	}

	@Override
	@Nonnull
	public Set<Capabilities> getCapabilities() {
	return capabilities;
	}

	@Override
	@Nonnull
	public Location getLocation() {
	return vfs.getLocation();
	}

	@Override
	@Nonnull
	public String getPath() {
	return vfs.getPath();
	}

	@Override
	@Nonnull
	public CaseInsensitiveVDir getRootDir() {
	used = true;

	return root;
	}

	@Override
	public synchronized void close() throws CannotCloseException {
	if (!closed) {
	try {
	PrintStream printer =
	new PrintStream(vfs.getRootDir().createVFile(INDEX_NAME).getOutputStream());

	printIndex(printer, getRootDir());
	printer.flush();
	printer.close();

	if (debug) {
	printer = new PrintStream(vfs.getRootDir().createVFile(DEBUG_NAME).getOutputStream());

	printDebug(printer, getRootDir());
	printer.flush();
	printer.close();
	}
	} catch (WrongPermissionException \| CannotCreateFileException e) {
	throw new CannotCloseException(this, e);
	}

	vfs.close();
	closed = true;
	}
	}

	private void printIndex(@Nonnull PrintStream printer, @Nonnull InMemoryVDir dir) {
	Collection<? extends BaseVElement> elements = dir.list();
	if (elements.size() > 0) {
	for (BaseVElement element : elements) {
	if (element.isVDir()) {
	printIndex(printer, (InMemoryVDir) element);
	} else {
	CaseInsensitiveVFile file = (CaseInsensitiveVFile) element;

	printer.print("f:");
	printer.print(file.getPath().getPathAsString(INDEX_SEPARATOR));
	printer.println();
	}
	}
	} else {
	printer.print("d:");
	printer.print(dir.getPath().getPathAsString(INDEX_SEPARATOR));
	printer.println();
	}
	}

	private void printDebug(@Nonnull PrintStream printer, @Nonnull InMemoryVDir dir) {
	Collection<? extends BaseVElement> elements = dir.list();

	printer.print("d:");
	printer.print(dir.getPath().getPathAsString(File.separatorChar));
	printer.println();

	for (BaseVElement element : elements) {
	if (element.isVDir()) {
	printDebug(printer, (InMemoryVDir) element);
	} else {
	CaseInsensitiveVFile file = (CaseInsensitiveVFile) element;

	printer.print("f:");
	printer.print(loadAndGetEncodedFile(file).getPath().getPathAsString(File.separatorChar));
	printer.print(":");
	printer.print(file.getPath().getPathAsString(File.separatorChar));
	printer.println();
	}
	}
	}

	//
	// Stream
	//

	@Nonnull
	private BaseVFile loadAndGetEncodedFile(@Nonnull CaseInsensitiveVFile file) {

	BaseVFile encodedFile = file.getEncodedFile();
	if (encodedFile == null) {
	try {
	encodedFile = vfs.getRootDir().getVFile(encode(file.getPath()));
	file.setEncodedFile(encodedFile);
	} catch (NotDirectoryException \| NotFileException \| NoSuchFileException e) {
	throw new RuntimeBadVFSFormatException(vfs, vfs.getLocation(), e);
	}
	}
	return encodedFile;
	}

	@Override
	@Nonnull
	InputStream openRead(@Nonnull CaseInsensitiveVFile file) throws WrongPermissionException {
	assert !isClosed();

	return loadAndGetEncodedFile(file).getInputStream();
	}

	@Override
	@Nonnull
	OutputStream openWrite(@Nonnull CaseInsensitiveVFile file) throws WrongPermissionException {
	return openWrite(file, false);
	}

	@Override
	@Nonnull
	OutputStream openWrite(@Nonnull CaseInsensitiveVFile file, boolean append)
	throws WrongPermissionException {
	assert !isClosed();

	return loadAndGetEncodedFile(file).getOutputStream(append);
	}

	//
	// VElement
	//

	@Override
	@Nonnull
	CaseInsensitiveVDir getVDir(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
	throws NotDirectoryException, NoSuchFileException {
	CaseInsensitiveVDir vDir = getVDirFromCache(parent, name);
	if (vDir != null) {
	return vDir;
	} else {
	throw new NoSuchFileException(getVDirLocation(parent, name));
	}
	}

	@Override
	@Nonnull
	CaseInsensitiveVFile getVFile(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
	throws NotFileException, NoSuchFileException {
	CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
	if (vFile != null) {
	return vFile;
	} else {
	throw new NoSuchFileException(getVFileLocation(parent, name));
	}
	}

	@CheckForNull
	CaseInsensitiveVFile getVFileFromCache(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
	throws NotFileException {
	BaseVElement element = parent.getFromCache(name);
	if (element == null) {
	return null;
	} else if (!element.isVDir()) {
	return (CaseInsensitiveVFile) element;
	} else {
	throw new NotFileException(getVFileLocation(parent, name));
	}
	}

	@CheckForNull
	CaseInsensitiveVDir getVDirFromCache(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name)
	throws NotDirectoryException {
	BaseVElement element = parent.getFromCache(name);
	if (element == null) {
	return null;
	} else if (element.isVDir()) {
	return (CaseInsensitiveVDir) element;
	} else {
	throw new NotDirectoryException(getVDirLocation(parent, name));
	}
	}

	@Override
	@Nonnull
	CaseInsensitiveVDir createVDir(@Nonnull CaseInsensitiveVDir parent,
	@Nonnull String name) throws CannotCreateFileException {
	assert !isClosed();

	try {
	return loadVDir(parent, name);
	} catch (NotDirectoryException e) {
	throw new CannotCreateFileException(getVDirLocation(parent, name));
	}
	}

	@Override
	@Nonnull
	synchronized CaseInsensitiveVFile createVFile(
	@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws CannotCreateFileException {
	assert !isClosed();
	try {
	CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
	if (vFile != null) {
	return vFile;
	} else {
	CaseInsensitiveVFile original = new CaseInsensitiveVFile(this, parent, name);
	BaseVFile encoded = vfs.getRootDir().createVFile(encode(original.getPath()));
	original.setEncodedFile(encoded);
	parent.putInCache(name, original);

	return original;
	}
	} catch (NotFileException e) {
	throw new CannotCreateFileException(getVFileLocation(parent, name));
	}
	}

	@Nonnull
	synchronized CaseInsensitiveVDir loadVDir(
	@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws NotDirectoryException {
	assert !isClosed();

	CaseInsensitiveVDir vDir = getVDirFromCache(parent, name);
	if (vDir != null) {
	return vDir;
	} else {
	CaseInsensitiveVDir dir = new CaseInsensitiveVDir(this, parent, name);
	parent.putInCache(name, dir);
	return dir;
	}
	}

	@Nonnull
	synchronized CaseInsensitiveVFile loadVFile(
	@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) throws NotFileException {
	assert !isClosed();
	CaseInsensitiveVFile vFile = getVFileFromCache(parent, name);
	if (vFile != null) {
	return vFile;
	} else {
	CaseInsensitiveVFile original = new CaseInsensitiveVFile(this, parent, name);
	parent.putInCache(name, original);

	return original;
	}
	}

	@Override
	@Nonnull
	void delete(@Nonnull CaseInsensitiveVFile file) throws CannotDeleteFileException {
	assert !isClosed();

	try {
	BaseVFile encoded = vfs.getRootDir().getVFile(encode(file.getPath()));
	vfs.delete(encoded);
	file.deleteFromCache();
	} catch (NotDirectoryException e) {
	throw new CannotDeleteFileException(file);
	} catch (NotFileException e) {
	throw new CannotDeleteFileException(file);
	} catch (NoSuchFileException e) {
	throw new CannotDeleteFileException(file);
	}
	}

	@Override
	@Nonnull
	Collection<? extends BaseVElement> list(@Nonnull CaseInsensitiveVDir dir) {
	return dir.getAllFromCache();
	}

	@Override
	boolean isEmpty(@Nonnull CaseInsensitiveVDir dir) {
	return dir.isEmpty();
	}

	@Override
	@Nonnull
	public FileTime getLastModified(@Nonnull CaseInsensitiveVFile file)
	throws CannotGetModificationTimeException {
	return vfs.getLastModified(loadAndGetEncodedFile(file));
	}

	//
	// Location
	//

	@Override
	@Nonnull
	Location getVFileLocation(@Nonnull CaseInsensitiveVFile file) {
	return vfs.getVFileLocation(loadAndGetEncodedFile(file));
	}

	@Override
	@Nonnull
	Location getVFileLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) {
	return vfs.getRootDir().getVFileLocation(
	encode(parent.getPath().clone().appendPath(new VPath(name, '/'))));
	}

	@Override
	@Nonnull
	Location getVDirLocation(@Nonnull CaseInsensitiveVDir dir) {
	return vfs.getRootDir().getVDirLocation(encode(dir.getPath()));
	}

	@Override
	@Nonnull
	Location getVDirLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull String name) {
	return vfs.getRootDir().getVDirLocation(
	encode(parent.getPath().clone().appendPath(new VPath(name, '/'))));
	}

	@Override
	@Nonnull
	Location getVFileLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull VPath path) {
	return vfs.getRootDir().getVFileLocation(encode(parent.getPath().clone().appendPath(path)));
	}

	@Override
	@Nonnull
	Location getVDirLocation(@Nonnull CaseInsensitiveVDir parent, @Nonnull VPath path) {
	return vfs.getRootDir().getVDirLocation(encode(parent.getPath().clone().appendPath(path)));
	}

	//
	// Misc
	//

	@Override
	public boolean needsSequentialWriting() {
	return vfs.needsSequentialWriting();
	}

	//
	// Encode / Decode
	//

	@Nonnull
	private VPath encode(@Nonnull VPath path) {
	char[] digest = encode(mdf.create().digest(path.getPathAsString('/').getBytes()));

	StringBuilder sb = new StringBuilder();
	int idx = 0;
	try {
	for (int groupIdx = 0; groupIdx < numGroups; groupIdx++) {
	for (int letterIdx = 0; letterIdx < groupSize; letterIdx++) {
	sb.append(digest[idx++]);
	}
	sb.append('/');
	}

	if (idx < digest.length) {
	sb.append(digest, idx, digest.length - idx);
	} else {
	// Remove the last /, it is not a directory here
	sb.setLength(sb.length() - 1);
	}
	} catch (IndexOutOfBoundsException e) {
	}


	return new VPath(sb.toString(), '/');
	}

	@Nonnull
	private static final byte[] code = "0123456789ABCDEF".getBytes();

	@Nonnull
	static char[] encode(@Nonnull byte[] bytes) {
	char[] array = new char[bytes.length * 2];

	for (int idx = 0; idx < bytes.length; idx++) {
	array[(idx << 1)] = (char) code[(bytes[idx] & 0xF0) >> 4];
	array[(idx << 1) + 1] = (char) code[(bytes[idx] & 0x0F)];
	}

	return array;
	}

	@Override
	@Nonnull
	VPath getPathFromDir(@Nonnull CaseInsensitiveVDir parent, @Nonnull CaseInsensitiveVFile file) {
	StringBuilder path = getPathFromDirInternal(parent, (CaseInsensitiveVDir) file.getParent())
	.append(file.getName());
	return new VPath(path.toString(), '/');
	}

	@Nonnull
	private StringBuilder getPathFromDirInternal(@Nonnull CaseInsensitiveVDir baseDir,
	@Nonnull CaseInsensitiveVDir currentDir) {
	if (baseDir == currentDir) {
	return new StringBuilder();
	}
	CaseInsensitiveVDir currentParent = (CaseInsensitiveVDir) currentDir.getParent();
	assert currentParent != null;
	return getPathFromDirInternal(baseDir, currentParent).append(currentDir.getName()).append('/');
	}

	@Override
	@Nonnull
	VPath getPathFromRoot(@Nonnull CaseInsensitiveVFile file) {
	return getPathFromDir(root, file);
	}

	@Override
	@Nonnull
	public StreamFileStatus getStatus() {
	if (!used) {
	return StreamFileStatus.NOT_USED;
	} else if (closed) {
	return StreamFileStatus.CLOSED;
	} else {
	return StreamFileStatus.OPEN;
	}
	}

	@Override
	@CheckForNull
	public String getInfoString() {
	return vfs.getInfoString();
	}

	@Override
	public String toString() {
	return "ciFS >> " + vfs.toString();
	}
	}