/*

    TiMidity -- Experimental MIDI to WAVE converter
    Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

   common.c

   */

#include <stdio.h>
#include <stdlib.h>

#ifndef NO_STRING_H
#    include <string.h>
#else
#    include <strings.h>
#endif

#ifndef OLD_FOPEN_METHOD
#    include <sys/types.h>
#    include <sys/stat.h>
#    include <fcntl.h>
#endif

#include <time.h>
#include <errno.h>
#include "gtim.h"
#include "common.h"
#include "output.h"
#include "controls.h"

/* I guess "rb" should be right for any libc */
#define OPEN_MODE "rb"

char   *program_name, current_filename[1024];
int     current_filedescriptor;

static PathList *pathlist = 0;

#ifdef __WIN32__
#    define R_OPEN_MODE O_RDONLY | O_BINARY
#else
#    define R_OPEN_MODE O_RDONLY
#endif

/* Try to open a file for reading. If the filename ends in one of the 
   defined compressor extensions, pipe the file through the decompressor */
static FILE *
try_to_open (char *name, int decompress)
{
    FILE   *fp;

#ifdef OLD_FOPEN_METHOD
    fp = fopen (name, OPEN_MODE);	/* First just check that the file exists */
#else
    if ((current_filedescriptor = open (name, R_OPEN_MODE)) == -1)
	return 0;
    fp = fdopen (current_filedescriptor, OPEN_MODE);
#endif

    if (!fp)
	return 0;

#ifdef DECOMPRESSOR_LIST
    if (decompress) {
	int     l, el;
	static const char *decompressor_list[] = DECOMPRESSOR_LIST, **dec;
	char    tmp[1024], tmp2[1024], *cp, *cp2;
	/* Check if it's a compressed file */
	l = strlen (name);
	for (dec = decompressor_list; *dec; dec += 2) {
	    el = strlen (*dec);
	    if ((el >= l) || (strcmp (name + l - el, *dec)))
		continue;

	    /* Yes. Close the file, open a pipe instead. */
	    fclose (fp);

	    /* Quote some special characters in the file name */
	    cp = name;
	    cp2 = tmp2;
	    while (*cp) {
		switch (*cp) {
		case '\'':
		case '\\':
		case ' ':
		case '`':
		case '!':
		case '"':
		case '&':
		case ';':
		    *cp2++ = '\\';
		}
		*cp2++ = *cp++;
	    }
	    *cp2 = 0;

	    sprintf (tmp, *(dec + 1), tmp2);
	    fp = popen (tmp, "r");
	    break;
	}
    }
#endif

    return fp;
}


/* This is meant to find and open files for reading, possibly piping
   them through a decompressor. */
FILE   *
open_file (const char *name, int decompress, int noise_mode, int level)
{
    FILE   *fp;
    PathList *plp = pathlist;
    int     l;

    if (!name || !(*name)) {
	ctl->cmsg (CMSG_ERROR, VERB_NORMAL,
		   "Attempted to open nameless file.");
	return 0;
    }

    /* First try the given name */

    strncpy (current_filename, name, 1023);
    current_filename[1023] = '\0';

    /* when called from read_config_file, do not look in current dir */
    if (level == 0 || name[0] == PATH_SEP) {
	ctl->cmsg (CMSG_INFO, VERB_DEBUG, "Trying to open %s",
		   current_filename);

	if ((fp = try_to_open (current_filename, decompress)))
	    return fp;

	if (noise_mode && (errno != ENOENT)) {
	    ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s",
		       current_filename, strerror (errno));
	    return 0;
	}
    }

    if (name[0] != PATH_SEP)
	while (plp) {		/* Try along the path then */
	    *current_filename = 0;
	    l = strlen (plp->path);
	    if (l) {
		strcpy (current_filename, plp->path);
		if (current_filename[l - 1] != PATH_SEP)
		    strcat (current_filename, PATH_STRING);
	    }
	    strcat (current_filename, name);
	    ctl->cmsg (CMSG_INFO, VERB_DEBUG, "Trying to open %s",
		       current_filename);
	    if ((fp = try_to_open (current_filename, decompress)))
		return fp;
	    if (noise_mode && (errno != ENOENT)) {
		ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s",
			   current_filename, strerror (errno));
		return 0;
	    }
	    plp = (PathList *) plp->next;
	}

    /* Nothing could be opened. */

    *current_filename = 0;

    if (noise_mode >= 2)
	ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s", name, strerror (errno));

    return 0;
}


/* This is meant to find and open files for reading. */
int
open_file_raw (const char *name, int noise_mode, int level)
{
    int   fd;
    PathList *plp = pathlist;
    int     l;

    if (!name || !(*name)) {
	ctl->cmsg (CMSG_ERROR, VERB_NORMAL,
		   "Attempted to open nameless file.");
	return -1;
    }

    /* First try the given name */

    strncpy (current_filename, name, 1023);
    current_filename[1023] = '\0';

    /* when called from read_config_file, do not look in current dir */
    if (level == 0 || name[0] == PATH_SEP) {
	ctl->cmsg (CMSG_INFO, VERB_DEBUG, "Trying to open %s",
		   current_filename);

	if ((fd = open (current_filename, R_OPEN_MODE)) > 0) {
     	    current_filedescriptor = fd;
	    return fd;
	}

	if (noise_mode && (errno != ENOENT)) {
	    ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s",
		       current_filename, strerror (errno));
	    return -1;
	}
    }

    if (name[0] != PATH_SEP)
	while (plp) {		/* Try along the path then */
	    *current_filename = 0;
	    l = strlen (plp->path);
	    if (l) {
		strcpy (current_filename, plp->path);
		if (current_filename[l - 1] != PATH_SEP)
		    strcat (current_filename, PATH_STRING);
	    }
	    strcat (current_filename, name);
	    ctl->cmsg (CMSG_INFO, VERB_DEBUG, "Trying to open %s",
		       current_filename);
	    if ((fd = open (current_filename, R_OPEN_MODE)) > 0) {
     	        current_filedescriptor = fd;
	        return fd;
	    }
	    if (noise_mode && (errno != ENOENT)) {
		ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s",
			   current_filename, strerror (errno));
		return -1;
	    }
	    plp = (PathList *) plp->next;
	}

    /* Nothing could be opened. */

    *current_filename = 0;

    if (noise_mode >= 2)
	ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: %s", name, strerror (errno));

    return -1;
}

/* This closes files opened with open_file */
void
close_file (FILE * fp)
{
#ifdef DECOMPRESSOR_LIST
    if (pclose (fp))		/* Any better ideas? */
#endif
	fclose (fp);
}

/* This is meant for skipping a few bytes in a file or fifo. */
void
skip (FILE * fp, size_t len)
{
    size_t  c;
    char    tmp[1024];
    while (len > 0) {
	c = len;
	if (c > 1024)
	    c = 1024;
	len -= c;
	if (c != fread (tmp, 1, c, fp))
	    ctl->cmsg (CMSG_ERROR, VERB_NORMAL, "%s: skip: %s",
		       current_filename, strerror (errno));
    }
}

/* This'll allocate memory or die. */
void   *
safe_malloc (size_t count)
{
    void   *p;
    if (count > (1 << 21)) {
	ctl->cmsg (CMSG_FATAL, VERB_NORMAL,
		   "Strange, I feel like allocating %d bytes. This must be a bug.",
		   count);
    }
    else if ((p = malloc (count)))
	return p;
    else
	ctl->cmsg (CMSG_FATAL, VERB_NORMAL,
		   "Sorry. Couldn't malloc %d bytes.", count);

    ctl->close ();
    play_mode->purge_output ();
    play_mode->close_output ();
    exit (10);
    return 0;
}

/* This adds a directory to the path list */
void
add_to_pathlist (char *s, int level)
{
    int     l;
    PathList *plp = (PathList *) safe_malloc (sizeof (PathList));

    if (s[0] == PATH_SEP)
	strcpy ((plp->path = (char *) safe_malloc (strlen (s) + 1)), s);
    else {
	PathList *pnp = pathlist;
	while (pnp && pnp->next && ((PathList *) (pnp->next))->level == level)
	    pnp = (PathList *) pnp->next;
	if (!pnp || !pnp->path)
	    return;
	l = strlen (pnp->path);
	plp->path = (char *) safe_malloc (l + strlen (s) + 2);
	if (l) {
	    strcpy (plp->path, pnp->path);
	    if (plp->path[l - 1] != PATH_SEP)
		strcat (plp->path, PATH_STRING);
	}
	else
	    plp->path[0] = '\0';
	strcat (plp->path, s);
    }
    plp->next = pathlist;
    plp->level = level;
    pathlist = plp;
}

/* This clears the path list of paths added from read_config_file. */
void
clear_pathlist (int level)
{
    PathList *nlp, *plp = pathlist, *prev = 0;
    while (plp) {
	nlp = (PathList *) plp->next;
	if (plp->level > level) {
	    if (plp == pathlist)
		pathlist = nlp;
	    free (plp->path);
	    free (plp);
	    if (prev)
		prev->next = nlp;
	}
	else
	    prev = plp;
	plp = nlp;
    }
}

#ifdef tplus
int int_rand(int n)
{
    if(n < 0)
    {
	if(n == -1)
	    srand((unsigned)time(NULL));
	else
	    srand((unsigned)-n);
	return n;
    }
    return (int)(n * (double)rand() * (1.0 / (RAND_MAX + 1.0)));
}
#endif
