/** \file filename.hpp .
-----------------------------------------------------------------------------


 * 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.

-----------------------------------------------------------------------------

   \brief A filename class

-------------------------------------------------------------------------- */

#ifndef __UIMA_FILENAME_HPP
#define __UIMA_FILENAME_HPP

/* ----------------------------------------------------------------------- */
/*       Interface dependencies                                            */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Implementation dependencies                                       */
/* ----------------------------------------------------------------------- */

#include "apr_file_info.h"
#include "apr_strings.h"
#include "apr_lib.h"
#include "uima/exceptions.hpp"
#include "uima/msg.h"

/* ----------------------------------------------------------------------- */
/*       Constants                                                         */
/* ----------------------------------------------------------------------- */

/* ----------------------------------------------------------------------- */
/*       Types / Classes                                                   */
/* ----------------------------------------------------------------------- */

namespace uima {
  namespace util {

    /**
     * The class <tt> FilenameCl</tt> is used to maintain filenames with all of its
     * (operating system specific) constituents: drive, path, base name and extension.
     * \code
       ???
      \endcode
     */

    class Filename {
    public:
      /** @name Constructors */
      /*@{*/
      /** create an empty filename */
      Filename(void);
      /** create a filename based on a filename given as a C string */
      Filename(const char * filename);

      /** create a filename based on a path, a filename and an optional extension,
          all given as C strings */
      Filename(const char * cpszPath,
               const char * cpszFilename,
               const char * cpszExtension = 0);
      /** copy constructor */
      Filename(const Filename & filename);
      /** destructor */
      ~Filename(void);
      /*@}*/
      /** @name Assignment operations */
      /*@{*/
      /** assign new complete filename */
      Filename &                 operator = (const Filename & filename);


      /** @name Properties */
      /*@{*/
      /** determine whether a file exists for filename on file system */
      bool                       isExistent(void) const;

      /** determine whether path has an absolute path specification */
      bool                       isAbsolute(void) const;

      /** return the size of this file in bytes.
          \note If the file does not exist a size of 0 bytes is returned. */
      unsigned long              getFileSize(void) const;

      /** @name Parts */
      /*@{*/
      /** return full filename as a C string pointer */
      const char *               getAsCString(void) const                     {
        return fname;
      }

      operator const char* (void) const            {
        return fname;
      }

      /** return the name part of this filename without the path but with the extension.
          \note If the filename part is empty, the function returns a pointer
          to an empty string, <em> not</em> a NULL pointer. */
      const char  *              getName(void) const;

      /** return the extension only, starting with the dot (e.g. ".so")
          \note If there is no extension, the function returns a pointer
          to an empty string, <em> not</em> a NULL pointer. */
      const char  *              getExtension(void) const;

      /** return the length of the complete filename */
      size_t                     getLength(void) const;

      /** assign a new entry from a path, optional filename and optional extension. */
      void                       setNew(const char * cpszPath,
                                        const char * cpszName = 0,
                                        const char * cpszExtension = 0);

      /** assign a new filename - keep current path.
          filename may include extension or not */
      void                       setNewName(const char * cpszName);

      /** assign a new extension - keep current path and filename.
          Specified extension must include the extension dot (".") */
      void                       setNewExtension(const char * cpszExtension);

      /** convert to an absolute name in native format with appropriate directory separators. */
      void                       normalizeAbsolute(void);

      /** convert to a name in native format with appropriate directory separators. */
      void                       normalize(void);

      /** copy path value to buffer pointed to by <tt> pszPath</tt>.
          If a path does not exist for this object, <tt> pszPath</tt> is set to the empty string.
          The path is returned with a terminating path separator character. */
      void                       extractPath(char * pszPath) const;

      /** copy base name (without path or extension) to buffer pointed to by <tt> pszBaseName</tt>. */
      void                        extractBaseName(char * pszBaseName) const;

      /** return TRUE if base names match (basic name part witout extension) */
      bool                       matchesBase(const Filename & crclFilename) const;

      /** search for file in a list of search paths and return TRUE if found */
      bool                       determinePath(const char* searchPaths);

      /*@}*/
    protected:
      /* --- functions --- */
    private:
      void                       createPool(void);

      apr_pool_t               * fnPool;
      char                     * fname;
    }
    ; /* Filename */

    /* ----------------------------------------------------------------------- */
    /*       Implementation                                                    */
    /* ----------------------------------------------------------------------- */

    /* ----------------------------------------------------------------------- */
    inline Filename::Filename(void) {
      createPool();
      fname = NULL;
    }

    /* ----------------------------------------------------------------------- */
    inline Filename::Filename(const char* filename) {
      createPool();
      fname = apr_pstrdup(fnPool, filename);
    }

    /* ----------------------------------------------------------------------- */
    inline Filename::Filename(const char * cpszPath, const char * cpszName,
                              const char * cpszExtension) {
      const char * fn;
      apr_status_t rv;

      createPool();
      if ( cpszExtension != NULL )
        fn = apr_pstrcat( fnPool,cpszName,cpszExtension,NULL );
      else
        fn = cpszName;
      // Add directory separator if necessary & normalize etc.
      rv = apr_filepath_merge(&fname, cpszPath, fn, APR_FILEPATH_NATIVE, fnPool);
      if (rv != APR_SUCCESS)
        fname = NULL;
    }

    /* ----------------------------------------------------------------------- */
    inline Filename::Filename(const Filename & filename) {
      createPool();
      fname = apr_pstrdup(fnPool, filename.getAsCString());
    }

    /* ----------------------------------------------------------------------- */
    inline Filename::~Filename(void) {
      if (fnPool != NULL)
        apr_pool_destroy(fnPool);
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::createPool(void) {
      if (apr_pool_create(&fnPool, NULL) != APR_SUCCESS) {
        fnPool = NULL;
        UIMA_EXC_THROW_NEW(ExcOutOfMemory,
                           UIMA_ERR_ENGINE_OUT_OF_MEMORY,
                           UIMA_MSG_ID_EXC_OUT_OF_MEMORY,
                           ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_POOL_FOR_CLASS,"uima::util::Filename"),
                           ErrorInfo::unrecoverable);
      }
    }

    /* ----------------------------------------------------------------------- */
    inline Filename & Filename::operator = (const Filename & filename) {
      // Must make a copy since RHS & its pool may disappear
      fname = apr_pstrdup(fnPool, filename.getAsCString());
      return *this;
    }

    /* ----------------------------------------------------------------------- */
    inline const char  * Filename::getName(void) const {
      if (fname == NULL)
        return NULL;
      else
        return apr_filepath_name_get(fname);
      // Probably returns a ptr to the end portion of fname so no memory allocated
    }

    /* ----------------------------------------------------------------------- */
    inline const char  * Filename::getExtension(void) const {
      if (fname == NULL)
        return NULL;
      else {
        const char* cpszExtn = strrchr(apr_filepath_name_get(fname), '.');
        return (cpszExtn!=NULL ? cpszExtn : "");
      }
    }

    /* ----------------------------------------------------------------------- */
    inline size_t Filename::getLength(void) const {
      if (fname == NULL)
        return 0;
      else
        return strlen(fname);
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::extractPath(char * pszPath) const {
      if (fname == NULL)
        *pszPath = '\0';
      else {
        // Get length of path up to the filename, copy with trailing separator and append a 0
        unsigned long len = apr_filepath_name_get(fname) - fname;
        strncpy(pszPath, fname, len);
        pszPath[len] = '\0';
      }
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::extractBaseName(char * pszBaseName) const {
      if (fname == NULL)
        *pszBaseName = '\0';
      else {
        // Get name after part and strip off extension (if any)
        const char* cpszName = apr_filepath_name_get(fname);
        const char* cpszExtn = strrchr(cpszName, '.');
        unsigned long len = cpszExtn==NULL ? strlen(cpszName) : cpszExtn - cpszName;
        strncpy(pszBaseName, cpszName, len);
        pszBaseName[len] = '\0';
      }
    }

    /* ----------------------------------------------------------------------- */
    inline bool Filename::isExistent(void) const {
      apr_finfo_t finfo;
      apr_status_t rv;

      // Check if can determine type (file, directory, pipe ...)
      rv = apr_stat(&finfo, fname, APR_FINFO_TYPE, fnPool);
      return !(APR_STATUS_IS_ENOENT(rv));
    }

    /* ----------------------------------------------------------------------- */
    inline bool Filename::isAbsolute(void) const {
      apr_status_t rv;
      const char * root;
      const char * fn = fname;

      // Modifies arg fn ... returns success if finds the root (?:\ on Windows)
      rv = apr_filepath_root(&root, &fn, 0, fnPool);
      return rv == APR_SUCCESS;
    }

    /* ----------------------------------------------------------------------- */
    inline bool Filename::matchesBase(const Filename & crclFilename) const {
      const char * cpszName1, * cpszName2, * cpszExtn1, * cpszExtn2;
      unsigned long len1, len2;

      if (fname == NULL)
        return FALSE;
      cpszName1 = apr_filepath_name_get(fname);
      cpszExtn1 = strrchr(cpszName1, '.');
      len1 = cpszExtn1==NULL ? strlen(cpszName1) : cpszExtn1 - cpszName1;

      cpszName2 = crclFilename.getName();
      if (cpszName2 == NULL)
        return FALSE;
      cpszExtn2 = strrchr(cpszName2, '.');
      len2 = cpszExtn2==NULL ? strlen(cpszName2) : cpszExtn2 - cpszName2;
      return (len1 == len2 && strncmp(cpszName1, cpszName2, len1) == 0);
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::setNew(const char * cpszPath, const char * cpszName,
                                 const char * cpszExtension) {
      // create new string from the 3 parts
      // The path must end in a separator & the extension must start with a '.'
      fname = apr_pstrcat( fnPool,cpszPath,cpszName,cpszExtension,NULL );
      return;
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::setNewName(const char * cpszName) {
      if (fname == NULL)
        return;
      // If new name is longer than old (or old had none) remove old
      // and create a new entry by concatenating new filename.
      char * pszName = (char*) apr_filepath_name_get(fname);
      if (strlen(pszName) >= strlen(cpszName))
        strcpy( pszName,cpszName );
      else {
        *pszName = '\0';
        fname = apr_pstrcat( fnPool,fname,cpszName,NULL );
      }
      return;
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::setNewExtension(const char * cpszExtension) {
      const char * cpszName;
      char * pszExtn;

      if (fname == NULL || cpszExtension == NULL)
        return;
      // If new extension not longer than old replace in place, otherwise
      // remove old and create a new entry by concatenating new extension.
      cpszName = apr_filepath_name_get(fname);
      pszExtn = CONST_CAST(char *, strrchr(cpszName, '.'));
      if ( pszExtn == NULL )
        fname = apr_pstrcat( fnPool,fname,cpszExtension,NULL );
      else {
        if (strlen(pszExtn) >= strlen(cpszExtension))
          strcpy(pszExtn, cpszExtension);
        else {
          *pszExtn = '\0';
          fname = apr_pstrcat( fnPool,fname,cpszExtension,NULL );
        }
      }
      return;
    }

    /* ----------------------------------------------------------------------- */
    inline unsigned long Filename::getFileSize(void) const {
      apr_finfo_t finfo;
      apr_status_t rv;

      rv = apr_stat(&finfo, fname, APR_FINFO_SIZE, fnPool);
      return rv == APR_SUCCESS ? finfo.size : 0;
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::normalizeAbsolute(void) {
      apr_status_t rv;
      char* newname;

      if (fname == NULL)
        return;
      rv = apr_filepath_merge(&newname, NULL, fname, APR_FILEPATH_NATIVE, fnPool);
      if (rv == APR_SUCCESS)
        fname = newname;
      return;
    }

    /* ----------------------------------------------------------------------- */
    inline void Filename::normalize(void) {
      apr_status_t rv;
      char* newname;

      if (fname == NULL)
        return;
      rv = apr_filepath_merge(&newname, ".", fname, APR_FILEPATH_NATIVE, fnPool);
      if (rv == APR_SUCCESS)
        fname = newname;
      return;
    }

    /* ----------------------------------------------------------------------- */
    inline bool Filename::determinePath(const char* searchPaths) {
      apr_array_header_t  * pathElts;
      char                * name;

      if (fname == NULL)
        return FALSE;
      // Drop any existing path
      name = (char*) apr_filepath_name_get(fname);
      apr_filepath_list_split(&pathElts, searchPaths, fnPool);              // Cannot fail!
      for ( int i = 0; i < pathElts->nelts; ++i ) {
        apr_filepath_merge(&fname, ((char**)pathElts->elts)[i], name, APR_FILEPATH_NATIVE, fnPool);
        if (isExistent())
          return TRUE;
      }
      return FALSE;
    }

  }  // namespace util
}  // namespace uima

#endif /* __UIMA_FILENAME_HPP */

/* <EOF> */