/*
    * 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
    *
    *     https://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.configuration2.io;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.net.URLStreamHandler;
  import java.util.Map;
  
  import org.apache.commons.configuration2.ex.ConfigurationException;
  import org.apache.commons.configuration2.ex.ConfigurationRuntimeException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.vfs2.FileContent;
  import org.apache.commons.vfs2.FileName;
  import org.apache.commons.vfs2.FileObject;
  import org.apache.commons.vfs2.FileSystemConfigBuilder;
  import org.apache.commons.vfs2.FileSystemException;
  import org.apache.commons.vfs2.FileSystemManager;
  import org.apache.commons.vfs2.FileSystemOptions;
  import org.apache.commons.vfs2.VFS;
  import org.apache.commons.vfs2.provider.UriParser;
  
  /**
   * FileSystem that uses <a href="https://commons.apache.org/proper/commons-vfs/">Apache Commons VFS</a>.
   *
   * @since 1.7
   */
  public class VFSFileSystem extends DefaultFileSystem {
  
      /**
       * Stream handler required to create URL.
       */
      private static final class VFSURLStreamHandler extends URLStreamHandler {
  
          @Override
          protected URLConnection openConnection(final URL url) throws IOException {
              throw new IOException("VFS URLs can only be used with VFS APIs");
          }
      }
  
      /** The logger. */
      private final Log log = LogFactory.getLog(getClass());
  
      public VFSFileSystem() {
          // empty
      }
  
      @Override
      public String getBasePath(final String path) {
          if (UriParser.extractScheme(path) == null) {
              return super.getBasePath(path);
          }
          try {
              final FileName parent = resolveURI(path).getParent();
              return parent != null ? parent.getURI() : null;
          } catch (final FileSystemException fse) {
              fse.printStackTrace();
              return null;
          }
      }
  
      @Override
      public String getFileName(final String path) {
          if (UriParser.extractScheme(path) == null) {
              return super.getFileName(path);
          }
          try {
              return resolveURI(path).getBaseName();
          } catch (final FileSystemException fse) {
              fse.printStackTrace();
              return null;
          }
      }
  
      @Override
      public InputStream getInputStream(final URL url) throws ConfigurationException {
          final FileObject file;
          try {
             final FileSystemOptions opts = getOptions(url.getProtocol());
             file = getManager().resolveFile(url.toString(), opts);
             if (!file.exists()) {
                 throw new ConfigurationException("File not found");
             }
             if (!file.isFile()) {
                 throw new ConfigurationException("Cannot load a configuration from a directory");
             }
             final FileContent content = file.getContent();
             if (content == null) {
                 throw new ConfigurationException("Cannot access content of %s", file.getName().getFriendlyURI());
             }
             return content.getInputStream();
         } catch (final FileSystemException e) {
             throw new ConfigurationException(e, "Unable to access %s", url);
         }
     }
 
     private FileSystemManager getManager() throws FileSystemException {
         return VFS.getManager();
     }
 
     private FileSystemOptions getOptions(final String scheme) {
         if (scheme == null) {
             return null;
         }
         final FileSystemOptions opts = new FileSystemOptions();
         final FileSystemConfigBuilder builder;
         try {
             builder = getManager().getFileSystemConfigBuilder(scheme);
         } catch (final Exception ex) {
             return null;
         }
         final FileOptionsProvider provider = getFileOptionsProvider();
         if (provider != null) {
             final Map<String, Object> map = provider.getOptions();
             if (map == null) {
                 return null;
             }
             int count = 0;
             for (final Map.Entry<String, Object> entry : map.entrySet()) {
                 try {
                     String key = entry.getKey();
                     if (FileOptionsProvider.CURRENT_USER.equals(key)) {
                         key = "creatorName";
                     }
                     setProperty(builder, opts, key, entry.getValue());
                     ++count;
                 } catch (final Exception ex) {
                     // Ignore an incorrect property.
                     continue;
                 }
             }
             if (count > 0) {
                 return opts;
             }
         }
         return null;
 
     }
 
     @Override
     public OutputStream getOutputStream(final URL url) throws ConfigurationException {
         try {
             final FileSystemOptions opts = getOptions(url.getProtocol());
             final FileObject file = getManager().resolveFile(url.toString(), opts);
             // throw an exception if the target URL is a directory
             if (file == null || file.isFolder()) {
                 throw new ConfigurationException("Cannot save a configuration to a directory");
             }
             final FileContent content = file.getContent();
 
             if (content == null) {
                 throw new ConfigurationException("Cannot access content of %s", url);
             }
             return content.getOutputStream();
         } catch (final FileSystemException e) {
             throw new ConfigurationException(e, "Unable to access ", url);
         }
     }
 
     @Override
     public String getPath(final File file, final URL url, final String basePath, final String fileName) {
         if (file != null) {
             return super.getPath(file, url, basePath, fileName);
         }
         try {
             if (url != null) {
                 final FileName name = resolveURI(url.toString());
                 if (name != null) {
                     return name.toString();
                 }
             }
             if (UriParser.extractScheme(fileName) != null) {
                 return fileName;
             }
             if (basePath != null) {
                 final FileName base = resolveURI(basePath);
                 return getManager().resolveName(base, fileName).getURI();
             }
             final FileName name = resolveURI(fileName);
             final FileName base = name.getParent();
             return getManager().resolveName(base, name.getBaseName()).getURI();
         } catch (final FileSystemException fse) {
             fse.printStackTrace();
             return null;
         }
     }
 
     @Override
     public URL getURL(final String basePath, final String file) throws MalformedURLException {
         if (basePath != null && UriParser.extractScheme(basePath) == null || basePath == null && UriParser.extractScheme(file) == null) {
             return super.getURL(basePath, file);
         }
         try {
             final FileName path;
             if (basePath != null && UriParser.extractScheme(file) == null) {
                 final FileName base = resolveURI(basePath);
                 path = getManager().resolveName(base, file);
             } else {
                 path = resolveURI(file);
             }
 
             final URLStreamHandler handler = new VFSURLStreamHandler();
             return new URL(null, path.getURI(), handler);
         } catch (final FileSystemException e) {
             throw new ConfigurationRuntimeException(e, "Could not parse basePath: %s and fileName: %s", basePath, file);
         }
     }
 
     @Override
     public URL locateFromURL(final String basePath, final String fileName) {
         final String fileScheme = UriParser.extractScheme(fileName);
         // Use DefaultFileSystem if basePath and fileName don't have a scheme.
         if ((basePath == null || UriParser.extractScheme(basePath) == null) && fileScheme == null) {
             return super.locateFromURL(basePath, fileName);
         }
         try {
             final FileObject file;
             // Only use the base path if the file name doesn't have a scheme.
             if (basePath != null && fileScheme == null) {
                 final String scheme = UriParser.extractScheme(basePath);
                 final FileSystemOptions opts = getOptions(scheme);
                 FileObject base = getManager().resolveFile(basePath, opts);
                 if (base.isFile()) {
                     base = base.getParent();
                 }
 
                 file = getManager().resolveFile(base, fileName);
             } else {
                 final FileSystemOptions opts = getOptions(fileScheme);
                 file = getManager().resolveFile(fileName, opts);
             }
 
             if (!file.exists()) {
                 return null;
             }
             final FileName path = file.getName();
             final URLStreamHandler handler = new VFSURLStreamHandler();
             return new URL(null, path.getURI(), handler);
         } catch (final FileSystemException | MalformedURLException fse) {
             return null;
         }
     }
 
     private FileName resolveURI(final String path) throws FileSystemException {
         return getManager().resolveURI(path);
     }
 
     private void setProperty(final FileSystemConfigBuilder builder, final FileSystemOptions options, final String key, final Object value) {
         final String methodName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1);
         final Class<?>[] paramTypes = new Class<?>[2];
         paramTypes[0] = FileSystemOptions.class;
         paramTypes[1] = value.getClass();
         try {
             final Method method = builder.getClass().getMethod(methodName, paramTypes);
             final Object[] params = new Object[2];
             params[0] = options;
             params[1] = value;
             method.invoke(builder, params);
         } catch (final Exception ex) {
             log.warn("Cannot access property '" + key + "'! Ignoring.", ex);
         }
     }
 }