/*
 * $XFree86: $
 *
 * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Keith Packard not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Keith Packard makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "fcint.h"

static unsigned int
FcFileCacheHash (const char *string)
{
    unsigned int    h = 0;
    char	    c;

    while ((c = *string++))
	h = (h << 1) ^ c;
    return h;
}

char *
FcFileCacheFind (FcFileCache	*cache,
		 const char	*file,
		 int		id,
		 int		*count)
{
    unsigned int    hash;
    const char	    *match;
    FcFileCacheEnt *c, *name;
    int		    maxid;
    struct stat	    statb;
    
    match = file;
    
    hash = FcFileCacheHash (match);
    name = 0;
    maxid = -1;
    for (c = cache->ents[hash % FC_FILE_CACHE_HASH_SIZE]; c; c = c->next)
    {
	if (c->hash == hash && !strcmp (match, c->file))
	{
	    if (c->id > maxid)
		maxid = c->id;
	    if (c->id == id)
	    {
		if (stat (file, &statb) < 0)
		{
		    if (FcDebug () & FC_DBG_CACHE)
			printf (" file missing\n");
		    return 0;
		}
		if (statb.st_mtime != c->time)
		{
		    if (FcDebug () & FC_DBG_CACHE)
			printf (" timestamp mismatch (was %d is %d)\n",
				(int) c->time, (int) statb.st_mtime);
		    return 0;
		}
		if (!c->referenced)
		{
		    cache->referenced++;
		    c->referenced = FcTrue;
		}
		name = c;
	    }
	}
    }
    if (!name)
	return 0;
    *count = maxid + 1;
    return name->name;
}

/*
 * Cache file syntax is quite simple:
 *
 * "file_name" id time "font_name" \n
 */
 
static FcBool
FcFileCacheReadString (FILE *f, char *dest, int len)
{
    int	    c;
    FcBool    escape;

    while ((c = getc (f)) != EOF)
	if (c == '"')
	    break;
    if (c == EOF)
	return FcFalse;
    if (len == 0)
	return FcFalse;
    
    escape = FcFalse;
    while ((c = getc (f)) != EOF)
    {
	if (!escape)
	{
	    switch (c) {
	    case '"':
		*dest++ = '\0';
		return FcTrue;
	    case '\\':
		escape = FcTrue;
		continue;
	    }
	}
        if (--len <= 1)
	    return FcFalse;
	*dest++ = c;
	escape = FcFalse;
    }
    return FcFalse;
}

static FcBool
FcFileCacheReadUlong (FILE *f, unsigned long *dest)
{
    unsigned long   t;
    int		    c;

    while ((c = getc (f)) != EOF)
    {
	if (!isspace (c))
	    break;
    }
    if (c == EOF)
	return FcFalse;
    t = 0;
    for (;;)
    {
	if (c == EOF || isspace (c))
	    break;
	if (!isdigit (c))
	    return FcFalse;
	t = t * 10 + (c - '0');
	c = getc (f);
    }
    *dest = t;
    return FcTrue;
}

static FcBool
FcFileCacheReadInt (FILE *f, int *dest)
{
    unsigned long   t;
    FcBool	    ret;

    ret = FcFileCacheReadUlong (f, &t);
    if (ret)
	*dest = (int) t;
    return ret;
}

static FcBool
FcFileCacheReadTime (FILE *f, time_t *dest)
{
    unsigned long   t;
    FcBool	    ret;

    ret = FcFileCacheReadUlong (f, &t);
    if (ret)
	*dest = (time_t) t;
    return ret;
}

static FcBool
FcFileCacheAdd (FcFileCache	*cache,
		 const char	*file,
		 int		id,
		 time_t		time,
		 const char	*name,
		 FcBool		replace)
{
    FcFileCacheEnt    *c;
    FcFileCacheEnt    **prev, *old;
    unsigned int    hash;

    if (FcDebug () & FC_DBG_CACHE)
    {
	printf ("%s face %s/%d as %s\n", replace ? "Replace" : "Add",
		file, id, name);
    }
    hash = FcFileCacheHash (file);
    for (prev = &cache->ents[hash % FC_FILE_CACHE_HASH_SIZE]; 
	 (old = *prev);
	 prev = &(*prev)->next)
    {
	if (old->hash == hash && old->id == id && !strcmp (old->file, file))
	    break;
    }
    if (*prev)
    {
	if (!replace)
	    return FcFalse;

	old = *prev;
	if (old->referenced)
	    cache->referenced--;
	*prev = old->next;
	free (old);
	cache->entries--;
    }
	
    c = malloc (sizeof (FcFileCacheEnt) +
		strlen (file) + 1 +
		strlen (name) + 1);
    if (!c)
	return FcFalse;
    c->next = *prev;
    *prev = c;
    c->hash = hash;
    c->file = (char *) (c + 1);
    c->id = id;
    c->name = c->file + strlen (file) + 1;
    strcpy (c->file, file);
    c->time = time;
    c->referenced = replace;
    strcpy (c->name, name);
    cache->entries++;
    return FcTrue;
}

FcFileCache *
FcFileCacheCreate (void)
{
    FcFileCache	*cache;
    int		h;

    cache = malloc (sizeof (FcFileCache));
    if (!cache)
	return 0;
    for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
	cache->ents[h] = 0;
    cache->entries = 0;
    cache->referenced = 0;
    cache->updated = FcFalse;
    return cache;
}

void
FcFileCacheDestroy (FcFileCache *cache)
{
    FcFileCacheEnt *c, *next;
    int		    h;

    for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
    {
	for (c = cache->ents[h]; c; c = next)
	{
	    next = c->next;
	    free (c);
	}
    }
    free (cache);
}

void
FcFileCacheLoad (FcFileCache	*cache,
		 const char	*cache_file)
{
    FILE	    *f;
    char	    file[8192];
    int		    id;
    time_t	    time;
    char	    name[8192];

    f = fopen (cache_file, "r");
    if (!f)
	return;

    cache->updated = FcFalse;
    while (FcFileCacheReadString (f, file, sizeof (file)) &&
	   FcFileCacheReadInt (f, &id) &&
	   FcFileCacheReadTime (f, &time) &&
	   FcFileCacheReadString (f, name, sizeof (name)))
    {
	(void) FcFileCacheAdd (cache, file, id, time, name, FcFalse);
    }
    fclose (f);
}

FcBool
FcFileCacheUpdate (FcFileCache	*cache,
		   const char	*file,
		   int		id,
		   const char	*name)
{
    const char	    *match;
    struct stat	    statb;
    FcBool	    ret;

    match = file;

    if (stat (file, &statb) < 0)
	return FcFalse;
    ret = FcFileCacheAdd (cache, match, id, 
			    statb.st_mtime, name, FcTrue);
    if (ret)
	cache->updated = FcTrue;
    return ret;
}

static FcBool
FcFileCacheWriteString (FILE *f, char *string)
{
    char    c;

    if (putc ('"', f) == EOF)
	return FcFalse;
    while ((c = *string++))
    {
	switch (c) {
	case '"':
	case '\\':
	    if (putc ('\\', f) == EOF)
		return FcFalse;
	    /* fall through */
	default:
	    if (putc (c, f) == EOF)
		return FcFalse;
	}
    }
    if (putc ('"', f) == EOF)
	return FcFalse;
    return FcTrue;
}

static FcBool
FcFileCacheWriteUlong (FILE *f, unsigned long t)
{
    int	    pow;
    unsigned long   temp, digit;

    temp = t;
    pow = 1;
    while (temp >= 10)
    {
	temp /= 10;
	pow *= 10;
    }
    temp = t;
    while (pow)
    {
	digit = temp / pow;
	if (putc ((char) digit + '0', f) == EOF)
	    return FcFalse;
	temp = temp - pow * digit;
	pow = pow / 10;
    }
    return FcTrue;
}

static FcBool
FcFileCacheWriteInt (FILE *f, int i)
{
    return FcFileCacheWriteUlong (f, (unsigned long) i);
}

static FcBool
FcFileCacheWriteTime (FILE *f, time_t t)
{
    return FcFileCacheWriteUlong (f, (unsigned long) t);
}

FcBool
FcFileCacheSave (FcFileCache	*cache,
		 const char	*cache_file)
{
    char	    *lck;
    char	    *tmp;
    FILE	    *f;
    int		    h;
    FcFileCacheEnt *c;

    if (!cache->updated && cache->referenced == cache->entries)
	return FcTrue;
    
    lck = malloc (strlen (cache_file)*2 + 4);
    if (!lck)
	goto bail0;
    tmp = lck + strlen (cache_file) + 2;
    strcpy (lck, cache_file);
    strcat (lck, "L");
    strcpy (tmp, cache_file);
    strcat (tmp, "T");
    if (link (lck, cache_file) < 0 && errno != ENOENT)
	goto bail1;
    if (access (tmp, F_OK) == 0)
	goto bail2;
    f = fopen (tmp, "w");
    if (!f)
	goto bail2;

    for (h = 0; h < FC_FILE_CACHE_HASH_SIZE; h++)
    {
	for (c = cache->ents[h]; c; c = c->next)
	{
	    if (!c->referenced)
		continue;
	    if (!FcFileCacheWriteString (f, c->file))
		goto bail4;
	    if (putc (' ', f) == EOF)
		goto bail4;
	    if (!FcFileCacheWriteInt (f, c->id))
		goto bail4;
	    if (putc (' ', f) == EOF)
		goto bail4;
	    if (!FcFileCacheWriteTime (f, c->time))
		goto bail4;
	    if (putc (' ', f) == EOF)
		goto bail4;
	    if (!FcFileCacheWriteString (f, c->name))
		goto bail4;
	    if (putc ('\n', f) == EOF)
		goto bail4;
	}
    }

    if (fclose (f) == EOF)
	goto bail3;
    
    if (rename (tmp, cache_file) < 0)
	goto bail3;
    
    unlink (lck);
    cache->updated = FcFalse;
    return FcTrue;

bail4:
    fclose (f);
bail3:
    unlink (tmp);
bail2:
    unlink (lck);
bail1:
    free (lck);
bail0:
    return FcFalse;
}

FcBool
FcFileCacheReadDir (FcFontSet *set, const char *cache_file)
{
    FcPattern	    *font;
    FILE	    *f;
    char	    *path;
    char	    *base;
    char	    file[8192];
    int		    id;
    char	    name[8192];
    FcBool	    ret = FcFalse;

    if (FcDebug () & FC_DBG_CACHE)
    {
	printf ("FcFileCacheReadDir cache_file \"%s\"\n", cache_file);
    }
    
    f = fopen (cache_file, "r");
    if (!f)
    {
	if (FcDebug () & FC_DBG_CACHE)
	{
	    printf (" no cache file\n");
	}
	goto bail0;
    }

    base = strrchr (cache_file, '/');
    if (!base)
	goto bail1;
    base++;
    path = malloc (base - cache_file + 8192 + 1);
    if (!path)
	goto bail1;
    memcpy (path, cache_file, base - cache_file);
    base = path + (base - cache_file);
    
    while (FcFileCacheReadString (f, file, sizeof (file)) &&
	   FcFileCacheReadInt (f, &id) &&
	   FcFileCacheReadString (f, name, sizeof (name)))
    {
	font = FcNameParse (name);
	if (font)
	{
	    strcpy (base, file);
	    if (FcDebug () & FC_DBG_CACHEV)
	    {
		printf (" dir cache file \"%s\"\n", file);
	    }
	    FcPatternAddString (font, FC_FILE, path);
	    if (!FcFontSetAdd (set, font))
		goto bail2;
	}
    }
    if (FcDebug () & FC_DBG_CACHE)
    {
	printf (" cache loaded\n");
    }
    
    ret = FcTrue;
bail2:
    free (path);
bail1:
    fclose (f);
bail0:
    return ret;
}

FcBool
FcFileCacheWriteDir (FcFontSet *set, const char *cache_file)
{
    FcPattern	    *font;
    FILE	    *f;
    char	    *name;
    char	    *file, *base;
    int		    n;
    int		    id;
    FcBool	    ret;

    if (FcDebug () & FC_DBG_CACHE)
	printf ("FcFileCacheWriteDir cache_file \"%s\"\n", cache_file);
    
    f = fopen (cache_file, "w");
    if (!f)
    {
	if (FcDebug () & FC_DBG_CACHE)
	    printf (" can't create \"%s\"\n", cache_file);
	goto bail0;
    }
    for (n = 0; n < set->nfont; n++)
    {
	font = set->fonts[n];
	if (FcPatternGetString (font, FC_FILE, 0, &file) != FcResultMatch)
	    goto bail1;
	base = strrchr (file, '/');
	if (base)
	    base = base + 1;
	else
	    base = file;
	if (FcPatternGetInteger (font, FC_INDEX, 0, &id) != FcResultMatch)
	    goto bail1;
	if (FcDebug () & FC_DBG_CACHEV)
	    printf (" write file \"%s\"\n", base);
	if (!FcFileCacheWriteString (f, base))
	    goto bail1;
	if (putc (' ', f) == EOF)
	    goto bail1;
	if (!FcFileCacheWriteInt (f, id))
	    goto bail1;
        if (putc (' ', f) == EOF)
	    goto bail1;
	name = FcNameUnparse (font);
	if (!name)
	    goto bail1;
	ret = FcFileCacheWriteString (f, name);
	free (name);
	if (!ret)
	    goto bail1;
	if (putc ('\n', f) == EOF)
	    goto bail1;
    }
    if (fclose (f) == EOF)
	goto bail0;
    
    if (FcDebug () & FC_DBG_CACHE)
	printf (" cache written\n");
    return FcTrue;
    
bail1:
    fclose (f);
bail0:
    unlink (cache_file);
    return FcFalse;
}