#include <String.h>

#include <u.h>
#include <libc.h>
#include <String.h>
#include "ftpfs.h"

enum
{
Chunk= 1024, /* chunk size for buffered data */
Nfile= 128, /* maximum number of cached files */
};

/* a file (with cached data) */
struct File
{
char *mem; /* part of file cached in memory */
ulong len; /* length of cached data */
long off; /* current offset into tpath */
short fd; /* fd to cache file */
char inuse;
char dirty;
ulong atime; /* time of last access */
Node *node;
char *template;
};

static File files[Nfile];
static ulong now;
static int ntmp;

/*
* lookup a file, create one if not found. if there are no
* free files, free the last oldest clean one.
*/
static File*
fileget(Node *node)
{
File *fp;
File *oldest;

fp = node->fp;
if(fp)
return fp;

oldest = 0;
for(fp = files; fp < &files[Nfile]; fp++){
if(fp->inuse == 0)
break;
if(fp->dirty == 0 && (oldest == 0 || oldest->atime > fp->atime))
oldest = fp;
}

if(fp == &files[Nfile]){
uncache(oldest->node);
fp = oldest;
}
node->fp = fp;
fp->node = node;
fp->atime = now++;
fp->inuse = 1;
fp->fd = -1;
if(fp->mem){
free(fp->mem);
fp->mem = nil;
}
return fp;
}

/*
* free a cached file
*/
void
filefree(Node *node)
{
File *fp;

fp = node->fp;
if(fp == 0)
return;

if(fp->fd >= 0){
ntmp--;
close(fp->fd);
remove(fp->template);
free(fp->template);
fp->template = 0;
}
fp->fd = -1;
if(fp->mem){
free(fp->mem);
fp->mem = nil;
}
fp->len = 0;
fp->inuse = 0;
fp->dirty = 0;

node->fp = 0;
}

/*
* satisfy read first from in memory chunk and then from temporary
* file. It's up to the caller to make sure that the file is valid.
*/
int
fileread(Node *node, char *a, long off, int n)
{
int sofar;
int i;
File *fp;

fp = node->fp;
if(fp == 0)
fatal("fileread");

if(off + n > fp->len)
n = fp->len - off;

for(sofar = 0; sofar < n; sofar += i, off += i, a += i){
if(off >= fp->len)
return sofar;
if(off < Chunk){
i = n;
if(off + i > Chunk)
i = Chunk - off;
memmove(a, fp->mem + off, i);
continue;
}
if(fp->off != off)
if(seek(fp->fd, off, 0) < 0){
fp->off = -1;
return -1;
}
i = read(fp->fd, a, n-sofar);
if(i < 0){
fp->off = -1;
return -1;
}
if(i == 0)
break;
fp->off = off + i;
}
return sofar;
}

void
uncachedir(Node *parent, Node *child)
{
Node *sp;

if(parent == 0 || parent == child)
return;
for(sp = parent->children; sp; sp = sp->sibs)
if(sp->opens == 0)
if(sp != child)
if(sp->fp != nil)
if(sp->fp->dirty == 0)
if(sp->fp->fd >= 0){
filefree(sp);
UNCACHED(sp);
}
}

static int
createtmp(File *fp)
{
char template[32];

strcpy(template, "/tmp/ftpXXXXXXXXXXX");
mktemp(template);
if(strcmp(template, "/") == 0){
fprint(2, "ftpfs can't create tmp file %s: %r\n", template);
return -1;
}
if(ntmp >= 16)
uncachedir(fp->node->parent, fp->node);

fp->fd = create(template, ORDWR|ORCLOSE, 0600);
fp->template = strdup(template);
fp->off = 0;
ntmp++;
return fp->fd;
}

/*
* write cached data (first Chunk bytes stay in memory)
*/
int
filewrite(Node *node, char *a, long off, int n)
{
int i, sofar;
File *fp;

fp = fileget(node);

if(fp->mem == nil){
fp->mem = malloc(Chunk);
if(fp->mem == nil)
return seterr("out of memory");
}

for(sofar = 0; sofar < n; sofar += i, off += i, a += i){
if(off < Chunk){
i = n;
if(off + i > Chunk)
i = Chunk - off;
memmove(fp->mem + off, a, i);
continue;
}
if(fp->fd < 0)
if(createtmp(fp) < 0)
return seterr("can't create temp file");
if(fp->off != off)
if(seek(fp->fd, off, 0) < 0){
fp->off = -1;
return seterr("can't seek temp file");
}
i = write(fp->fd, a, n-sofar);
if(i <= 0){
fp->off = -1;
return seterr("can't write temp file");
}
fp->off = off + i;
}

if(off > fp->len)
fp->len = off;
if(off > node->d->length)
node->d->length = off;
return sofar;
}

/*
* mark a file as dirty
*/
void
filedirty(Node *node)
{
File *fp;

fp = fileget(node);
fp->dirty = 1;
}

/*
* mark a file as clean
*/
void
fileclean(Node *node)
{
if(node->fp)
node->fp->dirty = 0;
}

int
fileisdirty(Node *node)
{
return node->fp && node->fp->dirty;
}