#include "funcprotos.h"
#include "quicktime.h"
#include <string.h>

#define DEFAULT_INFO "Made with Quicktime for Linux"
static char cpy_tag[] = {(char)0xa9, 'c', 'p', 'y'};
static char nam_tag[] = {(char)0xa9, 'n', 'a', 'm'};
static char inf_tag[] = {(char)0xa9, 'i', 'n', 'f'};
static char req_tag[] = {(char)0xa9, 'r', 'e', 'q'};
static char enc_tag[] = {(char)0xa9, 'e', 'n', 'c'};

int quicktime_udta_init(quicktime_udta_t *udta)
{
	udta->copyright = 0;
	udta->copyright_len = 0;
	udta->name = 0;
	udta->name_len = 0;
	udta->require = 0;
	udta->require_len = 0;
	udta->encoder = 0;
	udta->encoder_len = 0;

	udta->info = malloc(strlen(DEFAULT_INFO) + 1);
	udta->info_len = strlen(DEFAULT_INFO);
	sprintf(udta->info, DEFAULT_INFO);
	return 0;
}

int quicktime_udta_delete(quicktime_udta_t *udta)
{
	if(udta->copyright_len)
	{
		free(udta->copyright);
	}
	if(udta->name_len)
	{
		free(udta->name);
	}
	if(udta->info_len)
	{
		free(udta->info);
	}
	if(udta->require_len)
	{
		free(udta->require);
	}
	if(udta->encoder_len)
	{
		free(udta->encoder);
	}
//	quicktime_udta_init(udta);
	return 0;
}

void quicktime_udta_dump(quicktime_udta_t *udta)
{
	printf(" user data (udta)\n");
	if(udta->copyright_len) printf("  copyright -> %s\n", udta->copyright);
	if(udta->name_len) printf("  name -> %s\n", udta->name);
	if(udta->info_len) printf("  info -> %s\n", udta->info);
	if(udta->require_len) printf("  require -> %s\n", udta->require);
	if(udta->encoder_len) printf("  encoder -> %s\n", udta->encoder);
}

int quicktime_read_udta(quicktime_t *file, quicktime_udta_t *udta, quicktime_atom_t *udta_atom)
{
	quicktime_atom_t leaf_atom;
	int result = 0;

	do
	{
		quicktime_atom_read_header(file, &leaf_atom);


		if(quicktime_atom_is(&leaf_atom, cpy_tag))
		{
			result += quicktime_read_udta_string(file, &(udta->copyright), &(udta->copyright_len));
		}
		else
		if(quicktime_atom_is(&leaf_atom, nam_tag))
		{
			result += quicktime_read_udta_string(file, &(udta->name), &(udta->name_len));
		}
		else
		if(quicktime_atom_is(&leaf_atom, inf_tag))
		{
			result += quicktime_read_udta_string(file, &(udta->info), &(udta->info_len));
		}
		else
		if(quicktime_atom_is(&leaf_atom, req_tag))
		{
			result += quicktime_read_udta_string(file, &(udta->require), &(udta->require_len));
		}
		else
		if(quicktime_atom_is(&leaf_atom, enc_tag))
		{
			result += quicktime_read_udta_string(file, &(udta->encoder), &(udta->encoder_len));
		}
		else
		{
			quicktime_atom_skip(file, &leaf_atom);
		}
	}while(quicktime_position(file) < udta_atom->end);


	return result;
}

void quicktime_write_udta(quicktime_t *file, quicktime_udta_t *udta)
{
	quicktime_atom_t atom, subatom;
	quicktime_atom_write_header(file, &atom, "udta");

	if(udta->copyright_len)
	{
		quicktime_atom_write_header(file, &subatom, cpy_tag);
		quicktime_write_udta_string(file, udta->copyright, udta->copyright_len);
		quicktime_atom_write_footer(file, &subatom);
	}

	if(udta->name_len)
	{
		quicktime_atom_write_header(file, &subatom, nam_tag);
		quicktime_write_udta_string(file, udta->name, udta->name_len);
		quicktime_atom_write_footer(file, &subatom);
	}

	if(udta->info_len)
	{
		quicktime_atom_write_header(file, &subatom, inf_tag);
		quicktime_write_udta_string(file, udta->info, udta->info_len);
		quicktime_atom_write_footer(file, &subatom);
	}

	if(udta->require_len)
	{
		quicktime_atom_write_header(file, &subatom, req_tag);
		quicktime_write_udta_string(file, udta->require, udta->require_len);
		quicktime_atom_write_footer(file, &subatom);
	}

	if(udta->encoder_len)
	{
		quicktime_atom_write_header(file, &subatom, enc_tag);
		quicktime_write_udta_string(file, udta->encoder, udta->encoder_len);
		quicktime_atom_write_footer(file, &subatom);
	}

	quicktime_atom_write_footer(file, &atom);
}

int quicktime_read_udta_string(quicktime_t *file, char **string, int *size)
{
	int result;

	if(*size) free(*string);
	*size = quicktime_read_int16(file);  /* Size of string */
	quicktime_read_int16(file);  /* Discard language code */
	*string = malloc(*size + 1);
	result = quicktime_read_data(file, *string, *size);
	(*string)[*size] = 0;
	return !result;
}

int quicktime_write_udta_string(quicktime_t *file, char *string, int size)
{
	int new_size = strlen(string);
	int result;

	quicktime_write_int16(file, new_size);    /* String size */
	quicktime_write_int16(file, 0);    /* Language code */
	result = quicktime_write_data(file, string, new_size);
	return !result;
}

int quicktime_set_udta_string(char **string, int *size, char *new_string)
{
	if(*size) free(*string);
	*size = strlen(new_string) + 1;
	*string = malloc(*size);
	strcpy(*string, new_string);
	return 0;
}