/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libc
 * @{
 */
/**
 * @file
 * @brief ANSI C Stream I/O.
 */ 

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <bool.h>
#include <stdio.h>

FILE *stdin, *stdout, *stderr;

/**
 * Open a stream.
 *
 * @param file_name	Name of the file to open.
 * @param mode		Mode string, (r|w|a)[b|t][+].
 */
FILE *fopen(const char *file_name, const char *mode)
{
	FILE *f;
	int flags;
	bool plus;
	const char *mp;

	/* Parse mode except first character. */

	mp = mode;
	if (*mp++ == '\0') {
		errno = EINVAL;
		return NULL;
	}

	if (*mp == 'b' || *mp == 't') ++mp;

	if (*mp == '+') {
		++mp;
		plus = true;
	} else {
		plus = false;
	}

	if (*mp != '\0') {
		errno = EINVAL;
		return NULL;
	}

	/* Parse first character of mode and determine flags for open(). */

	switch (mode[0]) {
	case 'r':
		flags = plus ? O_RDWR : O_RDONLY;
		break;
	case 'w':
		flags = (O_TRUNC | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
		break;
	case 'a':
		/* TODO: a+ must read from beginning, append to the end. */
		if (plus) {
			errno = ENOTSUP;
			return NULL;
		}
		flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
	default:
		errno = EINVAL;
		return NULL;
	}

	/* Open file. */
	
	f = malloc(sizeof(FILE));
	if (f == NULL) {
		errno = ENOMEM;
		return NULL;
	}

	f->fd = open(file_name, flags, 0666);
	if (f->fd < 0) {
		free(f);
		return NULL; /* errno was set by open() */
	}

	f->error = 0;
	f->eof = 0;

	return f;
}

/** Close a stream.
 *
 * @param f	Pointer to stream.
 * @return	0 on success, EOF on error.
 */
int fclose(FILE *f)
{
	int rc;

	rc = close(f->fd);
	free(f);

	if (rc != 0)
		return EOF; /* errno was set by close() */

	return 0;
}

/** Read from a stream.
 *
 * @param buf	Destination buffer.
 * @param size	Size of each record.
 * @param nmemb Number of records to read.
 * @param f	Pointer to the stream.
 */
size_t fread(void *buf, size_t size, size_t nmemb, FILE *f)
{
	size_t left, done, n;

	left = size * nmemb;
	done = 0;

	while (left > 0 && !f->error && !f->eof) {
		n = read(f->fd, buf + done, left);

		if (n < 0) {
			f->error = 1;
		} else if (n == 0) {
			f->eof = 1;
		} else {
			left -= n;
			done += n;
		}
	}

	return done / size;
}


/** Write to a stream.
 *
 * @param buf	Source buffer.
 * @param size	Size of each record.
 * @param nmemb Number of records to write.
 * @param f	Pointer to the stream.
 */
size_t fwrite(const void *buf, size_t size, size_t nmemb, FILE *f)
{
	size_t left, done, n;

	left = size * nmemb;
	done = 0;

	while (left > 0 && !f->error) {
		n = write(f->fd, buf + done, left);

		if (n <= 0) {
			f->error = 1;
		} else {
			left -= n;
			done += n;
		}
	} 

	return done / size;
}

/** Return the end-of-file indicator of a stream. */
int feof(FILE *f)
{
	return f->eof;
}

/** Return the error indicator of a stream. */
int ferror(FILE *f)
{
	return f->error;
}

/** Clear the error and end-of-file indicators of a stream. */
void clearerr(FILE *f)
{
	f->eof = 0;
	f->error = 0;
}

/** Read character from a stream. */
int fgetc(FILE *f)
{
	unsigned char c;
	size_t n;

	n = fread(&c, sizeof(c), 1, f);
	if (n < 1) return EOF;

	return (int) c;
}

/** Write character to a stream. */
int fputc(int c, FILE *f)
{
	unsigned char cc;
	size_t n;

	cc = (unsigned char) c;
	n = fwrite(&cc, sizeof(cc), 1, f);
	if (n < 1) return EOF;

	return (int) cc;
}

/** Write string to a stream. */
int fputs(const char *s, FILE *f)
{
	int rc;

	rc = 0;

	while (*s && rc >= 0) {
		rc = fputc(*s++, f);
	}

	if (rc < 0) return EOF;

	return 0;
}

/** Seek to position in stream. */
int fseek(FILE *f, long offset, int origin)
{
	off_t rc;

	rc = lseek(f->fd, offset, origin);
	if (rc == (off_t) (-1)) {
		/* errno has been set by lseek. */
		return -1;
	}

	f->eof = 0;

	return 0;
}

/** @}
 */