/*
*******************************************************************************
*                                                                             *
* COPYRIGHT:                                                                  *
*   (C) Copyright International Business Machines Corporation, 1998           *
*   Licensed Material - Program-Property of IBM - All Rights Reserved.        *
*   US Government Users Restricted Rights - Use, duplication, or disclosure   *
*   restricted by GSA ADP Schedule Contract with IBM Corp.                    *
*                                                                             *
*******************************************************************************
*
* File ustdio.c
*
* Modification History:
*
*   Date        Name        Description
*   11/18/98    stephen	    Creation.
*   03/12/99    stephen     Modified for new C API.
*******************************************************************************
*/

#include "ustdio.h"
#include "ufile.h"
#include "ucnv.h"
#include "ustring.h"
#include "cmemory.h"

static const UChar DELIMITERS [] = { 0x000A, 0x0000 };

#define DELIM_CR 0x000D
#define DELIM_LF 0x000A

#define IS_STRING_DELIMITER(s)	(bool_t)(	(s) == DELIM_CR || \
						(s) == DELIM_LF	)


/* Input/output */

int32_t
u_fputs(const UChar *s,
	UFILE *f,
	UErrorCode *status)
{
  int32_t count;

  if(U_FAILURE(*status)) return 0;
  
  count = u_file_write(s, u_strlen(s), f, status);
  count += u_file_write(DELIMITERS, u_strlen(DELIMITERS), f, status);
  return count;
}

int32_t
u_fputc(UChar uc,
	UFILE *f,
	UErrorCode *status)
{
  if(U_FAILURE(*status)) return U_EOF;

  return u_file_write(&uc, 1, f, status) == 1 ? uc : U_EOF;
}

int32_t
u_file_write(const UChar *chars, 
	     int32_t count, 
	     UFILE *f,
	     UErrorCode *status)
{
  /* Set up conversion parameters */
  const UChar		*mySource   	= chars;
  const UChar		*sourceAlias   	= chars;
  const UChar		*mySourceEnd 	= chars + count;
  char			*myTarget 	= f->fCharBuffer;
  int32_t		bufferSize	= UFILE_CHARBUFFER_SIZE;
  int32_t		written		= 0;
 
  if(U_FAILURE(*status)) return U_EOF;
  
  /* Perform the conversion in a loop */
  do {
    *status 	= U_ZERO_ERROR;
    sourceAlias = mySource;
    
    ucnv_fromUnicode(f->fConverter,
		     &myTarget, 
		     f->fCharBuffer + bufferSize,
		     &mySource,
		     mySourceEnd,
		     NULL,
		     TRUE,
		     status);

    /* write the converted bytes */
    T_FileStream_write(f->fFile, 
		       f->fCharBuffer, 
		       sizeof(char) * (myTarget - f->fCharBuffer));
    
    written 	+= (myTarget - f->fCharBuffer);
    myTarget 	= f->fCharBuffer;
  }
  while(*status == U_INDEX_OUTOFBOUNDS_ERROR); 

  /* return # of chars written */
  return written;
}

UChar*
u_fgets(UFILE *f,
	int32_t n,
	UChar *s,
	UErrorCode *status)
{
  int32_t dataSize;
  int32_t read;
  int32_t count;
  UChar *alias;

  if(U_FAILURE(*status)) return 0;

  /* subtract 1 from n to compensate for the terminator */
  --n;

  /* determine the amount of data in the buffer */
  dataSize = f->fUCLimit - f->fUCPos;

  /* if the buffer contains more data than requested, operate on the buffer */
  if(dataSize > n) {

    /* find the first occurrence of a delimiter character */
    alias = f->fUCPos;
    count = 0;
    while( ! IS_STRING_DELIMITER(*alias) && count < n) {
      ++count;
      ++alias;
    }

    /* copy the characters into the target*/
    icu_memcpy(s, f->fUCPos, count * sizeof(UChar));

    /* add the terminator */
    s[count] = 0x0000;

    /* update the current buffer position */
    f->fUCPos += count;

    /* refill the buffer */
    ufile_fill_uchar_buffer(f, status);
    if(U_FAILURE(*status)) return 0;
    
    /* skip over any remaining delimiters */
    while(IS_STRING_DELIMITER(*(f->fUCPos)) && f->fUCPos < f->fUCLimit)
      ++(f->fUCPos);
    
    /* return s */
    return s;
  }

  /* otherwise, iteratively fill the buffer and copy */
  read = 0;
  do {
    
    /* refill the buffer */
    ufile_fill_uchar_buffer(f, status);
    if(U_FAILURE(*status)) return 0;
    
    /* determine the amount of data in the buffer */
    dataSize = f->fUCLimit - f->fUCPos;

    /* find the first occurrence of a delimiter character, if present */
    alias = f->fUCPos;
    count = 0;
    while( ! IS_STRING_DELIMITER(*alias) && alias < f->fUCLimit && count < n) {
      ++count;
      ++alias;
    }
    
    /* copy the current data in the buffer */
    memcpy(s + read, f->fUCPos, count * sizeof(UChar));
    
    /* update number of items read */
    read += count;

    /* update the current buffer position */
    f->fUCPos += count;

    /* if we found a delimiter */
    if(alias < f->fUCLimit) {

      /* refill the buffer */
      ufile_fill_uchar_buffer(f, status);
      if(U_FAILURE(*status)) return 0;

      /* skip over any remaining delimiters */
      while(IS_STRING_DELIMITER(*(f->fUCPos)) && f->fUCPos < f->fUCLimit)
	++(f->fUCPos);
      
      /* break out */
      break;
    }

  } while(dataSize != 0 && read < n);

  /* if 0 characters were read, return 0 */
  if(read == 0)
    return 0;

  /* add the terminator and return s */
  s[read] = 0x0000;
  return s;
}

UChar
u_fgetc(UFILE *f,
	UErrorCode *status)
{
  if(U_FAILURE(*status)) return U_EOF;

  /* if we have an available character in the buffer, return it */
  if(f->fUCPos < f->fUCLimit)
    return *(f->fUCPos)++;
  /* otherwise, fill the buffer and return the next character */
  else {
    ufile_fill_uchar_buffer(f, status);
    if(U_FAILURE(*status)) return U_EOF;
    if(f->fUCPos < f->fUCLimit) {
      return *(f->fUCPos)++;
    }
    /* at EOF */
    else {
      return U_EOF;
    }
  }
}

UChar
u_fungetc(UChar c,
	  UFILE *f,
	  UErrorCode *status)
{
  if(U_FAILURE(*status)) return U_EOF;

  /* if we're at the beginning of the buffer, sorry! */
  if(f->fUCPos == f->fUCBuffer) {
    *status = U_BUFFER_OVERFLOW_ERROR;
    return U_EOF;
  }
  /* otherwise, put the character back */
  else {
    *--(f->fUCPos) = c;
    return c;
  }
}

int32_t
u_file_read(UChar *chars, 
	    int32_t count, 
	    UFILE *f,
	    UErrorCode *status)
{
  int32_t dataSize;
  int32_t read;

  if(U_FAILURE(*status)) return 0;

  /* determine the amount of data in the buffer */
  dataSize = f->fUCLimit - f->fUCPos;

  /* if the buffer contains the amount requested, just copy */
  if(dataSize > count) {
    icu_memcpy(chars, f->fUCPos, count * sizeof(UChar));

    /* update the current buffer position */
    f->fUCPos += count;

    /* return # of chars read */
    return count;
  }

  /* otherwise, iteratively fill the buffer and copy */
  read = 0;
  do {
    
    /* refill the buffer */
    ufile_fill_uchar_buffer(f, status);
    if(U_FAILURE(*status)) return read;
    
    /* determine the amount of data in the buffer */
    dataSize = f->fUCLimit - f->fUCPos;

    /* copy the current data in the buffer */
    icu_memcpy(chars + read, f->fUCPos, dataSize * sizeof(UChar));
    
    /* update number of items read */
    read += dataSize;

    /* update the current buffer position */
    f->fUCPos += dataSize;

  } while(dataSize != 0 && read < count);
  
  return read;
}