/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

* System Includes

*

*/

#include <stdio.h>

#include <assert.h>

#include <errno.h>

#include <stdlib.h>

#ifndef WIN32

#include <unistd.h>

#else

#include <io.h>

#endif

#include <assert.h>

/******************************************************************************************************

 *

 * Local Includes

 *

 *****************************************************************************************************/

#include "file_utilities.h"

/******************************************************************************************************

 *

 * Definitions

 *

 *****************************************************************************************************/

#define TEMPFILE_SUFFIX               "XXXXXX"

#define MAXLINESIZE                    2048

#define COPYBUFFER                     2048

#define TEMPFILENAMESIZE               128

#define INSERT_TEMPFILE_PREFIX         "insert_tempfile."

#define MIN(a,b)                       (((a)<(b))?a:b)

/******************************************************************************************************

 *

 * Prototypes

 *

 *****************************************************************************************************/

#ifdef WIN32

static int mkstemp( char *aString );

#endif

/******************************************************************************************************

 *

 * PRIVATE METHOD: OpenTempfile

 *

 *****************************************************************************************************/

FILE *OpenTempfile( char *aFilenamePrefix, char *aFilename, int aLen, char *aMode, int *aSystemError )

{

  int err, prefix_len;

  FILE *fp;

  // check params

  assert( aFilenamePrefix != NULL );

  assert( aFilename != NULL );

  assert( aSystemError != NULL );

  assert( aLen > (strlen(TEMPFILE_SUFFIX) + 1) );

  *aSystemError = 0;

  // copy the prefix into the buffer

  prefix_len = MIN( strlen(aFilenamePrefix), (aLen - strlen(TEMPFILE_SUFFIX) - 1) );

  memcpy( aFilename, aFilenamePrefix, prefix_len );

  // copy the template into the buffer and NULL terminate

  memcpy( &(aFilename[prefix_len]), TEMPFILE_SUFFIX, strlen(TEMPFILE_SUFFIX) );

  aFilename[prefix_len + strlen(TEMPFILE_SUFFIX)] = 0;

  // get the filename

  err = mkstemp( aFilename );

  if( err == -1 ) { 

    *aSystemError = errno;

    return NULL;

  }

  // now open the file

  fp = fopen( aFilename, aMode );

  if( fp == NULL ) {

    *aSystemError = errno;

  }

  return fp;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: CopyFileByPtr

 *

 *****************************************************************************************************/

TFUError CopyFileByPtr( FILE *aSource, FILE *aDest, int *aSystemError )

{

  char buff[COPYBUFFER];

  int bytes_read, bytes_written;

  // check params

  assert( aSource != NULL );

  assert( aDest != NULL );

  assert( aSystemError != NULL );

  *aSystemError = 0;

  // now copy all the bytes

  while( 1 ) {

    // read from the source

    bytes_read = fread( buff, 1, COPYBUFFER, aSource );

    assert( bytes_read >= 0 );

    // check for read errors 

    if( ferror(aSource) != 0 ) {

      *aSystemError = errno;

      return FUE_READ_ERROR;

    }

    // if some bytes were read then write to the destination

    bytes_written = fwrite( buff, 1, bytes_read, aDest );

    assert( bytes_written >= 0 );

    // check for write errors

    if( bytes_written != bytes_read ) {

      *aSystemError = errno;

      return FUE_WRITE_ERROR;

    }

    // check for eof 

    if( feof(aSource) != 0 ) {

      return FUE_NONE;

    }

  }

  // done

  assert( !"INVALID CODE PATH" );

  return FUE_NONE;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: CopyFileByName

 *

 *****************************************************************************************************/

TFUError CopyFileByName( char *aSource, char *aDest, int *aSystemError )

{

  FILE *fpsrc, *fpdst;

  TFUError err;

  // check params

  assert( aSource != NULL );

  assert( aDest != NULL );

  assert( aSystemError != NULL );

  *aSystemError = 0;

  // open the source filename

  fpsrc = fopen( aSource, "r" );

  if( fpsrc == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // open the dest filename

  fpdst = fopen( aDest, "w" );

  if( fpdst == NULL ) {

    fclose( fpsrc );

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // copy the files

  err = CopyFileByPtr( fpsrc, fpdst, aSystemError );

  // close the files

  fflush( fpsrc );

  fflush( fpdst );

  fclose( fpsrc );

  fclose( fpdst );

  // if the copy failed then remove the new file

  if( err != FUE_NONE ) {

    unlink( aDest );

  }

  // done

  return err;      

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: InsertLine

 *

 *****************************************************************************************************/

TFUError InsertLine( char *aFilename, int aLineNumber, char *aLine, int aLineSize, int aReplaceFlag, int *aSystemError )

{

  char buff[COPYBUFFER], tempfilename[TEMPFILENAMESIZE];

  int i, end_of_file, err, insert_line_logic, line_inserted = 0;

  TFUError rv;

  FILE *fp_dest, *fp_source;

  // check params

  assert( aFilename != NULL );

  assert( (aLine != NULL) || (aLineSize == 0) );

  assert( aSystemError != NULL );

  assert( aLineNumber > 0 );

  *aSystemError = 0;

  // open the file

  fp_source = fopen( aFilename, "r" );

  if( fp_source == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_SOURCE_ERROR;

  }

  // now open the tempfile

  fp_dest = OpenTempfile( INSERT_TEMPFILE_PREFIX, tempfilename, TEMPFILENAMESIZE, "w", aSystemError );

  if( fp_dest == NULL ) {

    fclose( fp_source );

    return FUE_OPEN_TEMP_ERROR;

  }

  // now copy all files until we get to the target line - add the new line - then keep going

  for( i = 1; ; i++ ) {

    // read the next line from the source file 

    fgets( buff, COPYBUFFER, fp_source );

    // check for errors

    if( ferror(fp_source) != 0 ) {

      *aSystemError = errno;

      rv = FUE_READ_ERROR;

      break;

    }

    // see if we want to insert the newline at this point: we do if the user specified to insert before 

    // this line OR if we have hit the end of the file. In both cases there must be something to insert.

    end_of_file = feof( fp_source );

    insert_line_logic = ((aLineNumber == i) || ((line_inserted == 0)&&(end_of_file != 0)));

    if( (insert_line_logic != 0) && (aLineSize > 0) ) {

      fwrite( aLine, 1, aLineSize, fp_dest );

      if( ferror(fp_dest) != 0 ) {

	*aSystemError = errno;

	rv = FUE_WRITE_ERROR;

	break;

      }

      fputc( '\n', fp_dest );

      line_inserted = 1;

    }

    // if we have hit the end of the file then we are done

    if( end_of_file != 0 ) {

      rv = FUE_NONE;

      break;

    }

    // write the line just read -- unless we just inserted a line and the replace flag is set

    if( (insert_line_logic == 0) || (aReplaceFlag == 0) ) {

      fwrite( buff, 1, strlen(buff), fp_dest );

      if( ferror(fp_dest) != 0 ) {

		*aSystemError = errno;

		rv = FUE_WRITE_ERROR;

		break;

      }

    }

    // go to next line

  }

  // close both files

  fflush( fp_source );

  fflush( fp_dest );

  fclose( fp_source );

  fclose( fp_dest );

  // if we were successful then remove the original file and rename the new file to the original 

  // filename -- otherwise just remove the tempfile

  if( rv == FUE_NONE ) {

    unlink( aFilename );

    err = rename( tempfilename, aFilename );

    if( err != 0 ) {

      *aSystemError = errno;

      rv = FUE_RENAME_ERROR;

      unlink( tempfilename );

    }

  } else {

    unlink( tempfilename );

  }

  // done

  return rv;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: GetLine

 *

 *****************************************************************************************************/

TFUError GetLine( char *aFilename, int aLineNumber, char *aBuffer, int aBufferSize, int *aSystemError )

{

  FILE *fp;

  char *cline;

  int i;

  // check params

  assert( aLineNumber >= 0 );

  assert( aBuffer != NULL );

  assert( aSystemError != NULL );

  *aSystemError = 0;

  // open the file

  fp = fopen( aFilename, "r" );

  if( fp == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // read through the file until finding the appropriate line

  for( i = 0; i < aLineNumber; i++ ) {

    cline = fgets( aBuffer, aBufferSize, fp );

    if( cline == NULL )

      break;

  }

  // done with the file

  fflush( fp );

  fclose( fp );

  // if cline is null then we reached the end-of-file

  if( cline == NULL ) {

    return FUE_END_OF_FILE;

  }

  // otherwise just return -- the line is in the buffer

  return FUE_NONE;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: FindMatchingLines

 *

 *****************************************************************************************************/

TFUError FindMatchingLines( char *aFilename, char *aToken, int *aLineList, int *aListSize, int *aSystemError )

{

  int list_capacity, i, match;

  char cline[MAXLINESIZE], *cptr, *token_start, *token_end;

  FILE *fp;

  TFUError rv;

  // check params

  assert( aFilename != NULL );

  assert( aToken != NULL );

  assert( aLineList != NULL );

  assert( aListSize != NULL );

  assert( aSystemError != NULL );

  list_capacity = *aListSize;

  *aListSize = 0;

  *aSystemError = 0;

  // open the file

  fp = fopen( aFilename, "r" );

  if( fp == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // now read through the line and look for a line starting with the passed token (after whitespace and '#')

  for( i = 1; ; i++ ) {

    // read the next line

    cptr = fgets( cline, MAXLINESIZE, fp );

    // check for errors

    if( ferror(fp) != 0 ) {

      *aSystemError = errno;

      rv = FUE_READ_ERROR;

      break;

    }

    // check for end of file

    if( cptr == NULL ) {

      rv =  FUE_NONE;

      break;

    }

    // remove any whitespace (' ' + '\t') and hashes to find the start of the token

    for( token_start = cline; (*token_start == ' ') || (*token_start == '\t') || (*token_start == '#'); token_start++ )

      ;

    // now find the end of the token

    for( token_end = token_start; (*token_end != ' ') && (*token_end != '\t') && (*token_end != '\n') && (*token_end != 0); token_end++ ) 

      ;

    // null terminate the token - no need to save the old value

    *token_end = 0;

    // now compare the tokens and add the match

    match = strcmp( token_start, aToken );

    if( (match == 0) && ((*aListSize) < list_capacity) ) {

		aLineList[(*aListSize)++] = i;

    }

    // and do it all again

  }

  // close up the file and return

  fflush( fp );

  fclose( fp );

  // done

  return rv;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: FindMatchingLinesByRawPrefix

 *

 *****************************************************************************************************/

TFUError FindMatchingLinesByRawPrefix( char *aFilename, char *aToken, int *aLineList, int *aListSize, int *aSystemError )

{

  int list_capacity, i, match, token_length;

  char cline[MAXLINESIZE], *cptr;

  FILE *fp;

  TFUError rv;

  // check params

  assert( aFilename != NULL );

  assert( aToken != NULL );

  assert( aLineList != NULL );

  assert( aListSize != NULL );

  assert( aSystemError != NULL );

  list_capacity = *aListSize;

  *aListSize = 0;

  *aSystemError = 0;

  // get the length of the passed token

  token_length = strlen( aToken );

  assert( token_length > 0 );

  // open the file

  fp = fopen( aFilename, "r" );

  if( fp == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // now read through the line and look for a line starting with the passed token

  for( i = 1; ; i++ ) {

    // read the next line

    cptr = fgets( cline, MAXLINESIZE, fp );

    // check for errors

    if( ferror(fp) != 0 ) {

      *aSystemError = errno;

      rv = FUE_READ_ERROR;

      break;

    }

    // check for end of file

    if( cptr == NULL ) {

      rv =  FUE_NONE;

      break;

    }

    // now compare the tokens and add the match

    match = strncmp( cptr, aToken, token_length );

    if( (match == 0) && ((*aListSize) < list_capacity) ) {

		aLineList[(*aListSize)++] = i;

    }

    // and do it all again

  }

  // close up the file and return

  fflush( fp );

  fclose( fp );

  // done

  return rv;

}

/******************************************************************************************************

 *

 * PRIVATE METHOD: GetFileLineCount

 *

 *****************************************************************************************************/

TFUError GetFileLineCount( char *aFilename, int *aLineCount, int *aSystemError )

{

  FILE *fp;

  char cline[MAXLINESIZE], *cptr;

  // check params

  assert( aFilename != NULL );

  assert( aLineCount != NULL );

  assert( aSystemError != NULL );

  *aLineCount = *aSystemError = 0;

  // open the file

  fp = fopen( aFilename, "r" );

  if( fp == NULL ) {

    *aSystemError = errno;

    return FUE_OPEN_ERROR;

  }

  // read through the file and count the number of lines

  while( 1 ) {