/*
 * PDFlow -- pdfdoc.c
 *
 *  Copyright (c) 2010 Alberto Cuda
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 *  USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "fmt/file.h"
#include "pdfdoc.h"
#include "filters.h"

enum s_status pd_add_selection (struct v_selection *sel,
				struct v_pref *pref)
{
	struct v_selection scsel;
	enum s_status res;

	memset (&scsel, 0, sizeof (struct v_selection));
	scsel.pref = pref;
	res = S_CSC_OK;

	if (res == S_CSC_OK)
		res = flt_add_selection (&scsel);

	if (res == S_CSC_OK)
		res = xref_add_selection (&scsel);

	if (res == S_CSC_OK)
		res = cat_add_selection (&scsel);

	if (res != S_CSC_OK) {
		v_destroy_selection (&scsel);
		return res;
	}

	*sel = scsel;

	return S_CSC_OK;
}

enum s_status pd_init (struct pd_document **docp, struct ref_owner *p)
{
	struct pd_document *doc;

	doc = malloc (sizeof (struct pd_document));
	if (doc == NULL)
		return S_CSC_OUT_OF_MEMORY;
	memset (doc, 0, sizeof (struct pd_document));

	ref_init (&doc -> refs, "document", p);

	*docp = doc;

	return S_CSC_OK;
}

enum s_status pd_read (struct pd_document *doc, const char *fname)
{
	struct obj eobj;
	enum s_status res;
	struct f_file *file;

	res = f_open (fname, &file);
	if (res != S_CSC_OK)
		return res;

	res = xref_create_db (&doc -> rdb, ref_rown (&doc -> refs));
	if (res != S_CSC_OK) {
		f_unref (file);
		return res;
	}

	res = xref_init_db (doc -> rdb, file);
	f_unref (file);
	if (res != S_CSC_OK)
		return res;

	res = xref_dict_resolve (doc -> rdb, xref_get_trailer (doc -> rdb),
				 "Encrypt", OT_DICTIONARY, &eobj);
	if (res != S_CSC_OK)
		return res;

	if (eobj.type != OT_NULL) {
		obj_destroy (&eobj);

		return s_make_indirect 
			(S_CSC_NOT_SUPPORTED,
			 "Encrypted documents not supported yet");
	}
				 
	res = T_CALL (tri_init, &doc -> trailer, doc -> rdb, NULL,
		      xref_get_trailer (doc -> rdb), 
		      ref_rown (&doc -> refs));
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

enum s_status pd_creat (struct pd_document *doc, const char *fname,
			struct v_selection *sel)
{
	struct f_file *file;
	enum s_status res;

	res = f_creat (fname, &file);
	if (res != S_CSC_OK)
		return res;

	res = xref_create_db (&doc -> rdb, ref_rown (&doc -> refs));
	if (res != S_CSC_OK) {
		f_unref (file);
		return res;
	}

	res = xref_scratch_db (doc -> rdb, sel, file);
	f_unref (file);
	if (res != S_CSC_OK) 
		return res;

	res = T_CALL (tri_new, &doc -> trailer, doc -> rdb, 
		      ref_rown (&doc -> refs));
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

enum s_status pd_scratch (struct pd_document *doc, struct v_selection *sel)
{
	enum s_status res;

	res = xref_scratch_db (doc -> rdb, sel, NULL);
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

enum s_status pd_sync_start (struct pd_document *doc, struct v_selection *sel)
{
	enum s_status res;

	res = tri_touch (doc -> trailer);
	if (res != S_CSC_OK)
		return res;

	res = xref_sync_start (doc -> rdb, sel);
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}


enum s_status pd_sync_end (struct pd_document *doc, struct v_selection *sel)
{
	enum s_status res;
	struct obj obj;

	res = tri_fix_and_sync (doc -> rdb, sel, &obj, doc -> trailer);
	if (res != S_CSC_OK)
		return res;

	res = xref_sync_db (doc -> rdb, sel, &obj);
	obj_destroy (&obj);
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

enum s_status pd_sync (struct pd_document *doc, struct v_selection *sel)
{
	enum s_status res;
	
	res = pd_sync_start (doc, sel);
	if (res != S_CSC_OK)
		return res;

	res = pd_sync_end (doc, sel);
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

enum s_status pd_derive (struct pd_document *doc, struct pd_document *sdoc,
			 struct ob_bridge *ob)
{
	enum s_status res;

	res = tri_derive (doc -> trailer, sdoc -> trailer, ob);
	if (res != S_CSC_OK)
		return res;

	return S_CSC_OK;
}

void pd_unref (struct pd_document *doc, struct ref_owner *p)
{
	if (ref_down (&doc -> refs, p))
		return;

	if (doc -> rdb != NULL)
		xref_unref_db (doc -> rdb, ref_rown (&doc -> refs));

	if (doc -> trailer != NULL)
		tri_unref (doc -> trailer, ref_rown (&doc -> refs));

	ref_zero (&doc -> refs);

	free (doc);
}

void pd_unlink (struct pd_document *doc, struct ref_owner *p)
{
	xref_set_aborted (doc -> rdb);

	pd_unref (doc, p);
}