/*
 * The QUAFFLER library
 * Copyright (c) 2006 Clifford Wolf <clifford@clifford.at>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <string.h>
#include <stdio.h>
#include <netinet/in.h>

#include "quaffler.h"

int qfl_qmdf_generate(const char *filename, const char *trackeraddr, const char *attributes)
{
	QFL_OS_FILEHDL_TYPE file_in;
	QFL_OS_FILEHDL_TYPE file_out;

	if (qfl_os_open_ro(&file_in, filename))
		return -1;

	int filename_out_len = strlen(filename) + 6;
	char filename_out[filename_out_len];
	snprintf(filename_out, filename_out_len, "%s.qmdf", filename);

	if (qfl_os_open(&file_out, filename_out)) {
		qfl_os_close(&file_in);
		return -1;
	}

	qfl_os_truncate(&file_out);

	unsigned long long file_size = qfl_os_getsize(&file_in);

	char frag_scheme = 'A';
	int block_size = 1*1024*1024;
	if (file_size >  64*1024*1024*1024ll) { frag_scheme = 'B'; block_size =  2*1024*1024; }
	if (file_size > 128*1024*1024*1024ll) { frag_scheme = 'C'; block_size =  4*1024*1024; }
	if (file_size > 256*1024*1024*1024ll) { frag_scheme = 'D'; block_size =  8*1024*1024; }
	if (file_size > 512*1024*1024*1024ll) { frag_scheme = 'E'; block_size = 16*1024*1024; }

	int total_blocks = file_size / block_size;
	if (file_size % block_size) total_blocks++;

	int chunks_per_block = block_size / (64*1024);

	{
		unsigned int half_file_size;

		half_file_size = htonl((file_size & 0xffffffff00000000ll) >> 32);
		qfl_os_write(&file_out, 52, &half_file_size, 4);

		half_file_size = htonl((file_size & 0x00000000ffffffffll) >>  0);
		qfl_os_write(&file_out, 56, &half_file_size, 4);
	}

	qfl_os_write(&file_out, 60, &frag_scheme, 1);

	{
		unsigned char tracker_info[256];
		int i;

		for (i=0; i<256; i++)
			tracker_info[i] = 0x00;

		if (trackeraddr)
			strcpy((char*)tracker_info, trackeraddr);

		qfl_os_write(&file_out, 61, tracker_info, 256);
	}

	{
		unsigned char status = 0007;
		qfl_os_write(&file_out, 317, &status, 1);
	}

	long long offset_idxarray;
	long long offset_blockdata;

	{
		int bitmap_size = total_blocks / 8;
		if (total_blocks % 8) bitmap_size++;

		unsigned char bitmap[bitmap_size];
		int i;

		for (i=0; i<bitmap_size; i++)
			bitmap[i] = 0xff;

		qfl_os_write(&file_out, 318, bitmap, bitmap_size);

		for (i=0; i<bitmap_size; i++)
			bitmap[i] = 0x00;

		qfl_os_write(&file_out, 318 + bitmap_size, bitmap, bitmap_size);

		offset_idxarray = 318 + 2*bitmap_size;
		offset_blockdata = offset_idxarray + (total_blocks+1)*20;
	}

	{
		int bitmap_size = chunks_per_block / 8;
		unsigned char bitmap[bitmap_size];
		int i, j;

		for (i=0; i<bitmap_size; i++)
			bitmap[i] = 0xff;

		long long offset_idxarray_begin = offset_idxarray;
		long long offset = offset_blockdata;
		long long offset_in = 0;

		for (i=0; i<total_blocks; i++)
		{
			qfl_os_write(&file_out, offset, bitmap, bitmap_size);
			offset += bitmap_size;

			long long offset_begin = offset;

			for (j=0; j<chunks_per_block; j++)
			{
				unsigned char sha1[20];
				unsigned char data[64*1024];

				qfl_os_read(&file_in, offset_in, data, 64*1024);
				offset_in += 64*1024;

				qfl_sha1(data, 64*1024, sha1);

				qfl_os_write(&file_out, offset, sha1, 20);
				offset += 20;
			}

			int block_len = 20*chunks_per_block;
			unsigned char block[block_len];
			unsigned char sha1[20];

			qfl_os_read(&file_out, offset_begin, block, block_len);
			qfl_sha1(block, block_len, sha1);
			qfl_os_write(&file_out, offset_idxarray, sha1, 20);
			offset_idxarray += 20;
		}

		{
			unsigned short attr_len = attributes ? strlen(attributes) : 0;
			unsigned char sha1[20];

			qfl_os_write(&file_out, offset+2, attributes, attr_len);

			qfl_sha1((unsigned char*)attributes, attr_len, sha1);
			qfl_os_write(&file_out, offset_idxarray, sha1, 20);

			attr_len = htons(attr_len);
			qfl_os_write(&file_out, offset, &attr_len, 2);
		}

		int idxarray_len = (total_blocks+1)*20;
		unsigned char idxarray[idxarray_len];
		unsigned char sha1[20];

		qfl_os_read(&file_out, offset_idxarray_begin, idxarray, idxarray_len);
		qfl_sha1(idxarray, idxarray_len, sha1);
		qfl_os_write(&file_out, 32, sha1, 20);
	}

	char *banner = "-- QUAFFLER METADATA FILE V1 --\n";
	qfl_os_write(&file_out, 0, banner, 32);

	qfl_os_close(&file_in);
	qfl_os_close(&file_out);

	return 0;
}

static void print_hex(unsigned char *data, int len)
{
	int i;
	for (i=0; i<len; i++)
		printf("%02x", data[i]);
	printf("\n");
}

static void print_bits(unsigned char *data, int len)
{
	int i, j;
	for (i=0; i<len; i++) {
		if (i && i%8 == 0)
			printf("\n");
		for (j=0; j<8; j++)
			printf("%c", (data[i] & (1 << j)) ? 'X' : '.');
	}
	printf("\n");
}

#define READ(len) do { \
	qfl_os_read(&fh, offset, &buffer, (len)); \
	offset += len; buffer.b[len] = 0; } while (0)

int qfl_qmdf_dump(const char *filename)
{
	QFL_OS_FILEHDL_TYPE fh;

	int qmdf_filename_len = strlen(filename) + 6;
	char qmdf_filename[qmdf_filename_len];
	snprintf(qmdf_filename, qmdf_filename_len, "%s.qmdf", filename);

	if (qfl_os_open_ro(&fh, qmdf_filename))
		return -1;

	printf("\nQMDF Filename:\n%s\n", qmdf_filename);

	union {
		unsigned char b[64*1024];
		unsigned short w[32*1024];
		unsigned int d[16*1024];
	} buffer;

	unsigned long long offset = 0;

	READ(32);
	printf("\nBanner:\n%s", buffer.b);

	READ(20);
	printf("\nIndex Checksum:\n");
	print_hex(buffer.b, 20);

	READ(9);
	long long file_size = ((long long)ntohl(buffer.d[0]) << 32) | ntohl(buffer.d[1]);
	char frag_scheme = buffer.b[8];
	printf("\nFile size and fragmentation scheme:\n%Ld %c\n", file_size, frag_scheme);

	int block_size = 1*1024*1024;
	if (frag_scheme == 'B') block_size =  2*1024*1024;
	if (frag_scheme == 'C') block_size =  4*1024*1024;
	if (frag_scheme == 'D') block_size =  8*1024*1024;
	if (frag_scheme == 'E') block_size = 16*1024*1024;

	int total_blocks = file_size / block_size;
	if (file_size % block_size) total_blocks++;

	int chunks_per_block = block_size / (64*1024);

	READ(256);
	printf("\nTracker:\n%s\n", *buffer.b ? (char*)buffer.b : "** none **");

	READ(1);
	printf("\nStatus Flags:\n");
	printf("%c Got the entire file\n", buffer.b[0] & 0001 ? 'X' : '.');
	printf("%c Got the index metadata array\n", buffer.b[0] & 0002 ? 'X' : '.');
	printf("%c Got the attribute block\n", buffer.b[0] & 0004 ? 'X' : '.');
	// printf("%c unused\n", buffer.b[0] & 0010 ? 'X' : '.');
	// printf("%c unused\n", buffer.b[0] & 0020 ? 'X' : '.');
	// printf("%c unused\n", buffer.b[0] & 0040 ? 'X' : '.');
	// printf("%c unused\n", buffer.b[0] & 0100 ? 'X' : '.');
	// printf("%c unused\n", buffer.b[0] & 0200 ? 'X' : '.');

	{
		int bitmap_size = total_blocks / 8;
		if (total_blocks % 8) bitmap_size++;

		READ(bitmap_size);
		printf("\nBlock complete bitmap:\n");
		print_bits(buffer.b, bitmap_size);

		READ(bitmap_size);
		printf("\nBlock in-progres bitmap:\n");
		print_bits(buffer.b, bitmap_size);
	}

	{
		int i, j;

		printf("\nIndex metadata array:\n");
		for (i=0; i<=total_blocks; i++)
		{
			if (i<total_blocks) printf("blk %6d ", i);
			else printf("attributes ");

			READ(20);
			print_hex(buffer.b, 20);
		}

		int bitmap_size = chunks_per_block / 8;

		for (i=0; i<total_blocks; i++)
		{
			printf("\nBlock %d meta data:\n", i);

			READ(bitmap_size);
			printf("-bitmap- ");
			print_bits(buffer.b, bitmap_size);

			for (j=0; j<chunks_per_block; j++) {
				READ(20);
				printf("chunk %2d ", j);
				print_hex(buffer.b, 20);
			}
		}
	}

	{
		READ(2);
		int attr_size = ntohs(buffer.w[0]);

		READ(attr_size);
		printf("\nAttribute block (%d bytes):\n%s\n", attr_size, buffer.b);
	}

	printf("\n");
	qfl_os_close(&fh);

	return 0;
}

char *qfl_qmdf_to_uri(const char *filename, const char *tracker)
{
	QFL_OS_FILEHDL_TYPE fh;

	int qmdf_filename_len = strlen(filename) + 6;
	char qmdf_filename[qmdf_filename_len];
	snprintf(qmdf_filename, qmdf_filename_len, "%s.qmdf", filename);

	if (qfl_os_open_ro(&fh, qmdf_filename))
		return 0;

	union {
		unsigned char b[64*1024];
		unsigned short w[32*1024];
		unsigned int d[16*1024];
	} buffer;

	unsigned long long offset = 0;

	READ(32);
	if (strncmp((char*)buffer.b, "-- QUAFFLER METADATA FILE V1 --\n", 32)) {
		qfl_os_close(&fh);
		return 0;
	}

	char indexsha1[41];

	{
		int i;
		READ(20);
		for (i=0; i<20; i++)
			snprintf(indexsha1 + i*2, 3, "%02x", buffer.b[i]);
	}

	READ(9);
	long long file_size = ((long long)ntohl(buffer.d[0]) << 32) | ntohl(buffer.d[1]);
	char frag_scheme = buffer.b[8];

	if (!tracker) {
		READ(256);
		tracker = (char*)buffer.b;
	}

	if (!tracker[0] || strncmp(tracker, "TCP:", 4))
		tracker = "TCP:TRACKER-IP-ADDR-OR-DNS-NAME:PORT-NUMBER";

	qfl_os_close(&fh);

	int uri_len = strlen(filename) + strlen(tracker) + 100;
	char uri[uri_len];

	snprintf(uri, uri_len, "quaffler://%s/%s:%Ld:%c/%s",
		tracker+4, indexsha1, file_size, frag_scheme, filename);

	return strdup(uri);
}