/* direct_compress for fusecompress.
 * Copyright (C) 2005 Anders Aagaard <aagaande@gmail.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
/*
  implement open/close/read/write that I put in compress_module
    - change functions using compress/decompress there to use a function that uses the open/close/read/write functions instead?
  add direct_open/direct_close/direct_read/direct_write to fusecompress'es functions.
    - also fi->fh has to become filedata_h, and on the top of every function using it we need to LOCK_ENTRY and UNLOCK_ENTRY on the bottom.
    - fuse's open/release/write/read/truncate atleast (trunc has to count as write, and decompress file if we have more accesses)
    - truncate is special, we can set file to RAW without running it through decompress first.
*/
 
#include <pthread.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
 
#include "list.h"
#include "direct_compress.h"

pthread_mutex_t database_lock;
database_entry_h database;

static unsigned int gethash (const char *ptr)
{
	unsigned int hash;
	/* todo, tweak this, no more len, base it on ptr[0]? */
 
	for (hash = 0; *ptr; ptr++)
		hash = 31 * hash + *ptr;
	return hash;
}

// Returns locked database entry.
database_entry_h *direct_open(char *filename, struct compress_module *compressor)
{
	assert(filename);
	database_entry_h *entry = NULL;
	unsigned int target_hash = gethash(filename);
	
	LOCK_DATABASE;
	_CACHE_MSG("direct_open %s\n",filename);
	list_for_each_entry(entry, &database.list,list) {
		LOCK_ENTRY;
		if (entry->filename_hash == target_hash && (strcmp(entry->filename,filename) == 0)) {
			UNLOCK_DATABASE;
			entry->compressor = compressor;
			entry->accesses++;
			return entry; // RETURNED WITH LOCK
		}
	}
	
	// No entry found, allocate new.
	entry = malloc(sizeof(database_entry_h));
	LOCK_ENTRY;
	entry->compressor = compressor;
	entry->accesses = 1;
	entry->filename = strdup(filename);
	entry->filename_hash = target_hash;
	list_add(&entry->list,&database.list);
	
	UNLOCK_DATABASE;
}

// We need LOCK_ENTRY here.
void direct_close(filedata_h *filedata)
{
	if (filedata->compressor_data) {
		filedata->database->compressor->close((void *)filedata->compressor_data);
		free(filedata->compressor_data);
		filedata->compressor_data = NULL;
	}
}

/*
  We need LOCK_ENTRY here.
  This function returns TRUE on data read ok (length in returned_len), FALSE on use pread instead and FAIL on error.
*/
int direct_decompress(filedata_h *filedata,void *buffer, size_t size, int offset, int *returned_len)
{
	// If offset is wrong, we need to close and open in raw mode.
	if (offset != filedata->offset) {
		direct_close(filedata);
		if (decompress(filedata->fd,filedata->database->filename,filedata->database->compressor) == FAIL)
			return FAIL;
		filedata->database->compressor = NULL;
		return FALSE;
	}

	// Open file if neccesary
	assert(filedata->database->compressor);
	if (!filedata->compressor_data) {
		assert(filedata->offset == 0);
		filedata->compressor_data = COMPRESSOR_OPEN(filedata->fd,"rb");
		if (!filedata->compressor_data)
			return FAIL;
	}
	
	// Do actual decompressing.
	assert(filedata->compressor_data);
	*returned_len = COMPRESSOR_READ(filedata->compressor_data,buffer,size);
	if (*returned_len == -1)
		return FAIL;
	return TRUE;
}

/*
  We need LOCK_ENTRY here.
  This function returns TRUE on data read ok (length in returned_len), FALSE on use pwrite instead and FAIL on error.
*/
int direct_compress(filedata_h *filedata, void *buffer, size_t size, int offset, int *returned_len)
{
	// If accesses > 0 we need to decompress, can't have write and read (... actually we can, but lets ignore that for now) or multiple writes
	if (offset != filedata->offset || filedata->database->accesses > 0) {
		direct_close(filedata);
		if (decompress(filedata->fd,filedata->database->filename,filedata->database->compressor) == FAIL)
			return FAIL;
		filedata->database->compressor = NULL;
		return FALSE;
	}
	
	// Open file if neccesary
	assert(filedata->database->compressor);
	if (!filedata->compressor_data) {
		assert(filedata->offset == 0);
		filedata->compressor_data = COMPRESSOR_OPEN(filedata->fd,"wb9");
		if (!filedata->compressor_data)
			return FAIL;
	}
	
	// Do actual compressing.
	assert(filedata->compressor_data);
	*returned_len = COMPRESSOR_WRITE(filedata->compressor_data,buffer,size);
	if (*returned_len == -1)
		return FAIL;
	return TRUE;
}