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


 /*******************************************
 	Includes
  ******************************************/

 #ifndef _OSL_THREAD_H_
 #include "osl/thread.h"
 #endif
  
 #ifndef _OSL_FILE_PATH_HELPER_H_
 #include "file_path_helper.h"
 #endif
 
 #ifndef _OSL_FILE_PATH_HELPER_HXX_
 #include "file_path_helper.hxx"
 #endif
 
 #ifndef _OSL_UUNXAPI_HXX_
 #include "uunxapi.hxx"
 #endif
 
 #ifndef _OSL_DIAGNOSE_H_
 #include <osl/diagnose.h>
 #endif
 
 #ifndef _RTL_USTRING_HXX_
 #include <rtl/ustring.hxx>
 #endif

 /*******************************************
 	Constants
  ******************************************/
  
  const sal_Unicode FPH_CHAR_PATH_SEPARATOR = (sal_Unicode)'\\';
  const sal_Unicode FPH_CHAR_DOT            = (sal_Unicode)'.';
  const sal_Unicode FPH_CHAR_COLON          = (sal_Unicode)':';
  
  inline const rtl::OUString FPH_PATH_SEPARATOR()
      { return rtl::OUString::createFromAscii("\\"); }
  inline const rtl::OUString FPH_LOCAL_DIR_ENTRY()
      { return rtl::OUString::createFromAscii("."); }
  inline const rtl::OUString FPH_PARENT_DIR_ENTRY()
      { return rtl::OUString::createFromAscii(".."); }
  
 /*******************************************
  *  osl_systemPathRemoveSeparator   
  ******************************************/
  
 void SAL_CALL osl_systemPathRemoveSeparator(rtl_uString* pustrPath)
 {
 	OSL_PRECOND(pustrPath, "osl_systemPathRemoveSeparator: Invalid parameter");
		
	// maybe there are more than one separator at end 
	// so we run in a loop
	while ((pustrPath->length > 1) && (FPH_CHAR_PATH_SEPARATOR == pustrPath->buffer[pustrPath->length - 1]))
	{
		pustrPath->length--;
		pustrPath->buffer[pustrPath->length] = (sal_Unicode)'\0';
	}
	
	OSL_POSTCOND((0 == pustrPath->length) || (1 == pustrPath->length) || \
				 (pustrPath->length > 1 && pustrPath->buffer[pustrPath->length - 1] != FPH_CHAR_PATH_SEPARATOR), \
				 "osl_systemPathRemoveSeparator: Post condition failed");	
 }
 
 /*******************************************
    osl_systemPathEnsureSeparator   
  ******************************************/
  
 void SAL_CALL osl_systemPathEnsureSeparator(rtl_uString** ppustrPath)
 {
 	OSL_PRECOND(ppustrPath && (NULL != *ppustrPath), \
				"osl_systemPathEnsureSeparator: Invalid parameter");
	
 	rtl::OUString path(*ppustrPath);
	sal_Int32	  lp = path.getLength();
	sal_Int32     i  = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);
	
	if ((lp > 1 && i != (lp - 1)) || ((lp < 2) && i < 0))
	{
		path += FPH_PATH_SEPARATOR(); 
		rtl_uString_assign(ppustrPath, path.pData);			
	}
	
	OSL_POSTCOND(path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR) == (path.getLength() - 1), \
				 "osl_systemPathEnsureSeparator: Post condition failed");
 }
 
 /*******************************************
  *  osl_systemPathIsRelativePath
  ******************************************/
  
 sal_Bool SAL_CALL osl_systemPathIsRelativePath(const rtl_uString* pustrPath)
 {
 	OSL_PRECOND(pustrPath, "osl_systemPathIsRelativePath: Invalid parameter");
 	return (!osl_systemPathIsAbsolutePath(pustrPath));
 }
 
 /******************************************
  *  osl_systemPathIsAbsolutePath   		 
  *****************************************/
  
 sal_Bool SAL_CALL osl_systemPathIsAbsolutePath(const rtl_uString* pustrPath)
 {
 	OSL_PRECOND(pustrPath, "osl_systemPathIsAbsolutePath: Invalid parameter");
	if (pustrPath->length == 0)
		return sal_False;
	if (pustrPath->buffer[0] == FPH_CHAR_PATH_SEPARATOR)
		return sal_True;
	if (pustrPath->buffer[1] == FPH_CHAR_COLON
		    && pustrPath->buffer[2] == FPH_CHAR_PATH_SEPARATOR)
		return sal_True;
	return sal_False;
 }
 
 /******************************************
    osl_systemPathMakeAbsolutePath
  *****************************************/
  
 void SAL_CALL osl_systemPathMakeAbsolutePath(
 	const rtl_uString* pustrBasePath, 
	const rtl_uString* pustrRelPath, 
	rtl_uString** 	   ppustrAbsolutePath)
{
	rtl::OUString base(rtl_uString_getStr(const_cast<rtl_uString*>(pustrBasePath)));
	rtl::OUString rel(const_cast<rtl_uString*>(pustrRelPath));
	
	if (base.getLength() > 0)
		osl_systemPathEnsureSeparator(&base.pData);		
		
	base += rel;
	
	rtl_uString_acquire(base.pData);
	*ppustrAbsolutePath = base.pData; 
}

 
 /*****************************************
	osl_systemPathGetParent	
  ****************************************/
  
 sal_Int32 SAL_CALL osl_systemPathGetParent(rtl_uString* pustrPath)
 {
 	return 0;
 }
  
 /*******************************************
 	osl_systemPathGetFileOrLastDirectoryPart
  ******************************************/
  
 void SAL_CALL osl_systemPathGetFileNameOrLastDirectoryPart(
 	const rtl_uString* 	pustrPath,
	rtl_uString** 		ppustrFileNameOrLastDirPart)
{
	OSL_PRECOND(pustrPath && ppustrFileNameOrLastDirPart, \
			    "osl_systemPathGetFileNameOrLastDirectoryPart: Invalid parameter");
	
	rtl::OUString path(const_cast<rtl_uString*>(pustrPath));	
	
	osl_systemPathRemoveSeparator(path.pData);
				
	rtl::OUString last_part;
		
	if (path.getLength() > 1 || (1 == path.getLength() && *path.getStr() != FPH_CHAR_PATH_SEPARATOR))
	{
		sal_Int32 idx_ps = path.lastIndexOf(FPH_CHAR_PATH_SEPARATOR);		
		idx_ps++; // always right to increment by one even if idx_ps == -1!
		last_part = rtl::OUString(path.getStr() + idx_ps); 
	}							
	rtl_uString_assign(ppustrFileNameOrLastDirPart, last_part.pData);		
}
	

 /********************************************
 	osl_systemPathIsHiddenFileOrDirectoryEntry	
 *********************************************/
 
 sal_Bool SAL_CALL osl_systemPathIsHiddenFileOrDirectoryEntry(
 	const rtl_uString* pustrPath)
{
	OSL_PRECOND(pustrPath, "osl_systemPathIsHiddenFileOrDirectoryEntry: Invalid parameter");

	sal_Bool is_hidden = sal_False;
	
	if (pustrPath->length > 0)
	{
		rtl::OUString fdp;
	
		osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &fdp.pData);
		
		is_hidden = ((fdp.pData->length > 0) && (fdp.pData->buffer[0] == FPH_CHAR_DOT) && 
					 !osl_systemPathIsLocalOrParentDirectoryEntry(fdp.pData));					 
 	}
	
	return is_hidden;
}
	
 
 /************************************************
 	osl_systemPathIsLocalOrParentDirectoryEntry
 ************************************************/

sal_Bool SAL_CALL osl_systemPathIsLocalOrParentDirectoryEntry(
	const rtl_uString* pustrPath)
{
	OSL_PRECOND(pustrPath, "osl_systemPathIsLocalOrParentDirectoryEntry: Invalid parameter");
	
	rtl::OUString dirent;
	
	osl_systemPathGetFileNameOrLastDirectoryPart(pustrPath, &dirent.pData);
		
	return (
	        (dirent == FPH_LOCAL_DIR_ENTRY()) || 
	        (dirent == FPH_PARENT_DIR_ENTRY())
	       );
}
	
/***********************************************
 Simple iterator for a path list separated by 
 the specified character
 **********************************************/
 
class path_list_iterator
{
public:
	
	/******************************************
 	 constructor
	 
	 after construction get_current_item 
	 returns the first path in list, no need
	 to call reset first
	 *****************************************/	 
	path_list_iterator(const rtl::OUString& path_list, sal_Unicode list_separator = FPH_CHAR_COLON) : 
		m_path_list(path_list),
		m_end(m_path_list.getStr() + m_path_list.getLength() + 1),
		m_separator(list_separator)
	{
		reset();
	}
	
	/******************************************
	 reset the iterator
	 *****************************************/	 
	void reset()
	{
		m_path_segment_begin = m_path_segment_end = m_path_list.getStr();
		advance();				
	}
	
	/******************************************
	 move the iterator to the next position
	 *****************************************/	 
	void next()
	{
		OSL_PRECOND(!done(), "path_list_iterator: Already done!");
		
		m_path_segment_begin = ++m_path_segment_end;				
		advance();		
	}
	
	/******************************************
	 check if done
	 *****************************************/	 
	bool done() const
	{
		return (m_path_segment_end >= m_end);
	}
	
	/******************************************
	 return the current item
	 *****************************************/	 
	rtl::OUString get_current_item() const
	{
		return rtl::OUString(
			m_path_segment_begin, 
			(m_path_segment_end - m_path_segment_begin));
	}
		
private:
	
	/******************************************
	 move m_path_end to the next separator or
	 to the edn of the string
	 *****************************************/	 
	void advance()
	{
		while (!done() && *m_path_segment_end && (*m_path_segment_end != m_separator))
			++m_path_segment_end;
			
		OSL_ASSERT(m_path_segment_end <= m_end);
	}
	
private:
	rtl::OUString 		m_path_list;	
	const sal_Unicode*  m_end;
	const sal_Unicode 	m_separator;
	const sal_Unicode*  m_path_segment_begin;
	const sal_Unicode*  m_path_segment_end;	
	
// prevent copy and assignment	
private:
	/******************************************
	 copy constructor
	 remember: do not simply copy m_path_begin
	 and m_path_end because they point to 
	 the memory of other.m_path_list!
	 *****************************************/	 
	path_list_iterator(const path_list_iterator& other);
	
	/******************************************
	 assignment operator
 	 remember: do not simply copy m_path_begin
	 and m_path_end because they point to 
	 the memory of other.m_path_list!
	 *****************************************/	 
	path_list_iterator& operator=(const path_list_iterator& other);
};

 /************************************************
  	osl_searchPath
  ***********************************************/
  
sal_Bool SAL_CALL osl_searchPath( 	
 	const rtl_uString* pustrFilePath,
	const rtl_uString* pustrSearchPathList,
	rtl_uString**      ppustrPathFound)
{
	OSL_PRECOND(pustrFilePath && pustrSearchPathList && ppustrPathFound, "osl_searchPath: Invalid parameter");
	
	bool               bfound = false;
	rtl::OUString      fp(const_cast<rtl_uString*>(pustrFilePath));	
	rtl::OUString      pl = rtl::OUString(const_cast<rtl_uString*>(pustrSearchPathList));
	path_list_iterator pli(pl);
	
	while (!pli.done())
	{
		rtl::OUString p = pli.get_current_item();						
		osl::systemPathEnsureSeparator(p);		
		p += fp;
		
		if (osl::access(p, F_OK) > -1)
		{
			bfound = true;
			rtl_uString_assign(ppustrPathFound, p.pData);
			break;
		}					
		pli.next();
	}	
	return bfound;
}