/*
 * 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.uima.resource.impl;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Map;

import org.apache.uima.UIMARuntimeException;
import org.apache.uima.resource.DataResource;
import org.apache.uima.resource.FileResourceSpecifier;
import org.apache.uima.resource.RelativePathResolver;
import org.apache.uima.resource.ResourceInitializationException;
import org.apache.uima.resource.ResourceSpecifier;
import org.apache.uima.resource.Resource_ImplBase;
import org.apache.uima.util.UriUtils;

/**
 * A simple {@link DataResource} implementation that can read data from a file via a URL. There is
 * an attribute for specifying the location of a local cache for a remote file, but this is not
 * currently being used.
 * 
 * 
 */
public class DataResource_impl extends Resource_ImplBase implements DataResource {

  /** URL of file. */
  private URL mFileUrl;

  /** Filename of local cache, if any. */
  private File mLocalCache;

  /**
   * Initializes this DataResource.
   * 
   * @param aSpecifier
   *          describes how to create this DataResource. Must (at least for now) be a
   *          {@link FileResourceSpecifier}.
   * @param aAdditionalParams
   *          not currently used
   * 
   * @return true if and only if initialization completed successfully. Returns false if this
   *         implementation cannot handle the given <code>ResourceSpecifier</code>.
   * 
   * @see org.apache.uima.resource.Resource#initialize(ResourceSpecifier)
   */
  public boolean initialize(ResourceSpecifier aSpecifier, Map<String, Object> aAdditionalParams)
          throws ResourceInitializationException {
    // aSpecifier must be a FileResourceSpecifier
    if (!(aSpecifier instanceof FileResourceSpecifier))
      return false;

    // If we get here, aSpecifier is supported by this implementation.
    FileResourceSpecifier spec = (FileResourceSpecifier) aSpecifier;

    // Get Relative Path Resolver
    RelativePathResolver relPathResolver = null;
    if (aAdditionalParams != null) {
      relPathResolver = (RelativePathResolver) aAdditionalParams.get(PARAM_RELATIVE_PATH_RESOLVER);
    }
    if (relPathResolver == null) {
      relPathResolver = new RelativePathResolver_impl();
    }
      
    // Get the file URL, resolving relative path as necessary
    IOException ioEx = null;
    try {
      // Get the file URL from the specifier.  If the user has passed a file path
      // (e.g. c:\Program Files\...) instead of a URL, be lenient and convert it to
      // a URL
      URL relativeUrl;
      try {
        relativeUrl = new URL(spec.getFileUrl());
      }
      catch (MalformedURLException e) {
        //try to treat the URL as a file name.  
        File file = new File(spec.getFileUrl());
        if (file.isAbsolute()) {
          //for absolute paths, use File.toURL(), which handles
          //windows absolute paths correctly
          relativeUrl = file.toURL();
        } else {
          //for relative paths, we can' use File.toURL() because it always
          //produces an absolute URL.  Instead we do the following, which
          //won't work for windows absolute paths (but that's OK, since we
          //know we're working with a relative path)
          relativeUrl = new URL("file", "", spec.getFileUrl());
        }
      }
      
      //resolve relative paths
      mFileUrl = relPathResolver.resolveRelativePath(relativeUrl);

      // Store local cache info, even though it is not used
      if (spec.getLocalCache() == null) {
        mLocalCache = null;
      } else {
        mLocalCache = new File(spec.getLocalCache());
      }

    } catch (IOException e) {
      ioEx = e;
    }
    if (mFileUrl == null) {
      throw new ResourceInitializationException(
              ResourceInitializationException.COULD_NOT_ACCESS_DATA, new Object[] { spec
                      .getFileUrl() }, ioEx);
    }

    return true;
  }

  /**
   * @see org.apache.uima.resource.Resource#destroy()
   */
  public void destroy() {
  }

  /**
   * @see org.apache.uima.resource.DataResource#getInputStream()
   */
  public InputStream getInputStream() throws IOException {
    return mFileUrl.openStream();
  }

  /**
   * @see org.apache.uima.resource.DataResource#getUrl()
   */
  public URL getUrl() {
    return mFileUrl;
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.apache.uima.resource.DataResource#getUri()
   */
  public URI getUri() {
    try {
      return UriUtils.quote(mFileUrl);
    } catch (URISyntaxException e) {
      throw new UIMARuntimeException(e);
    }
  }

  /**
   * Gets the file name of the local cache for a remote resource file, if any.
   * 
   * @return the local cache File
   */
  protected File getLocalCache() {
    return mLocalCache;
  }

  /**
   * @see DataResource#equals(java.lang.Object)
   */
  public boolean equals(Object obj) {
    // obj must be a DataResource_impl
    if (!(obj instanceof DataResource_impl))
      return false;

    // URLs must be the same (but don't use URL.equals(), which does DNS resolution!)
    URL url = ((DataResource_impl) obj).getUrl();
    if (url == null || !url.toString().equals(this.getUrl().toString()))
      return false;

    // Local Cache Files must be the same
    File localCache = ((DataResource_impl) obj).getLocalCache();
    if (localCache == null && this.getLocalCache() != null)
      return false;

    if (localCache != null && !localCache.equals(this.getLocalCache()))
      return false;

    return true;
  }

  /**
   * @see DataResource#hashCode()
   */
  public int hashCode() {
    // add hash codes of member variables
    int hashCode = 0;
    if (mFileUrl != null)
      hashCode += mFileUrl.toString().hashCode(); //don't use URL.hashCode(), which does DNS resolution
    if (mLocalCache != null)
      hashCode += mLocalCache.hashCode();

    return hashCode;
  }
}
