/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License v3 as published by the Free
Software Foundation.

LiveCode 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 LiveCode.  If not see <http://www.gnu.org/licenses/>.  */

#include "prefix.h"

#include "globdefs.h"
#include "objdefs.h"
#include "parsedef.h"
#include "filedefs.h"

#include "scriptpt.h"

#include "cmds.h"
#include "chunk.h"
#include "mcerror.h"
#include "object.h"
#include "stack.h"
#include "card.h"
#include "printer.h"
#include "util.h"
#include "globals.h"
#include "securemode.h"
#include "exec.h"

#include "graphics_util.h"

MCPrint::MCPrint()
{
	mode = PM_CARD;
	target = NULL;
	from = NULL;
	to = NULL;
	rect = NULL;
	initial_state = NULL;
	bookmark_closed = false;
}

MCPrint::~MCPrint()
{
	delete target;
	delete from;
	delete to;
	delete rect;
	delete initial_state;
}

// This parses the following forms:
//   print break
//   print ( all | marked ) cards [ of <chunk> ] [ from <expr> to <expr> ] [ into <expr> ]
//   print <chunk> [ from <expr> to <expr> ] [ into <expr> ]
//   print <chunk> cards [ from <expr> to <expr> ] [ into <expr> ]
//
// New interactivity related print syntax:
//   print anchor <name> at <position>
//   print link to <anchor or url> with rect[angle] <rect>
//
Parse_stat MCPrint::parse(MCScriptPoint &sp)
{
	Symbol_type type;
	const LT *te;
	Boolean single = False;

	initpoint(sp);

	// print anchor <name> at <position>
	//   <name> -> from
	//   <position> -> rect
	//
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_ANCHOR) == PS_NORMAL)
	{
		mode = PM_ANCHOR;

		if (sp . parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_BADNAMEEXP, sp);
			return PS_ERROR;
		}

		if (sp . skip_token(SP_FACTOR, TT_PREP, PT_AT) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_NOATEXP, sp);
			return PS_ERROR;
		}

		if (sp . parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_BADTOEXP, sp);
			return PS_ERROR;
		}

		return PS_NORMAL;
	}

	// print link to [ url | anchor ] <anchor or url> with rect[angle] <rect>
	//   <anchor or url> -> to
	//   <rect> -> rect
	//
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_LINK) == PS_NORMAL)
	{
		mode = PM_LINK;

		if (sp . skip_token(SP_FACTOR, TT_TO, PT_TO) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_NOTOEXP, sp);
			return PS_ERROR;
		}

		if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_ANCHOR) == PS_NORMAL)
			mode = PM_LINK_ANCHOR;
		else if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_URL) == PS_NORMAL)
			mode = PM_LINK_URL;

		if (sp . parseexp(False, True, &to) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_BADTOEXP, sp);
			return PS_ERROR;
		}
		
		if (sp . skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) != PS_NORMAL ||
			sp . skip_token(SP_FACTOR, TT_PROPERTY, P_RECTANGLE) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_NOAREAEXP, sp);
			return PS_ERROR;
		}

		if (sp . parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_BADAREAEXP, sp);
			return PS_ERROR;
		}

		return PS_NORMAL;
	}

	// print [unicode] bookmark <title> [with level <level>] [at <position>]
	//   <title> -> from
	//   <level> -> to
	//   <position> -> rect
	if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_UNICODE) == PS_NORMAL)
		mode = PM_UNICODE_BOOKMARK;
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_BOOKMARK) != PS_NORMAL)
	{
		if (mode == PM_UNICODE_BOOKMARK)
		{
			MCperror->add(PE_PRINTBOOKMARK_NOBOOKMARK, sp);
			return PS_ERROR;
		}
	}
	else
	{
		if (mode != PM_UNICODE_BOOKMARK)
			mode = PM_BOOKMARK;

		if (sp.parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror->add(PE_PRINTBOOKMARK_BADTITLEEXP, sp);
			return PS_ERROR;
		}
		if (sp.skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) == PS_NORMAL)
		{
			if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_LEVEL) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_NOLEVEL, sp);
				return PS_ERROR;
			}
			if (sp.parseexp(False, True, &to) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADLEVELEXP, sp);
				return PS_ERROR;
			}
		}
		if (sp.skip_token(SP_FACTOR, TT_PREP, PT_AT) == PS_NORMAL)
		{
			if (sp.parseexp(False, True, &rect) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADATEXP, sp);
				return PS_ERROR;
			}
		}
		if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_INITIALLY) == PS_NORMAL)
		{
			if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_OPEN) == PS_NORMAL)
				bookmark_closed = false;
			else if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_CLOSED) == PS_NORMAL)
				bookmark_closed = true;
			else if (sp.parseexp(False, True, &initial_state) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADINITIALEXP, sp);
				return PS_ERROR;
			}
		}

		return PS_NORMAL;
	}

	// Rest of the print syntax
	if (sp.next(type) == PS_NORMAL)
	{
		if (sp.lookup(SP_SHOW, te) == PS_NORMAL)
		{
			if (te->which == SO_ALL || te->which == SO_MARKED)
			{
				mode = (Show_object)te->which == SO_ALL ? PM_ALL : PM_MARKED;
				if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) != PS_NORMAL)
				{
					MCperror->add(PE_PRINT_BADTARGET, sp);
					return PS_ERROR;
				}
			}
			else if (te->which == SO_BREAK)
			{
				sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_BREAK);
				mode = PM_BREAK;
				return PS_NORMAL;
			}
			else if (te->which == SO_CARD)
			{
				MCScriptPoint oldsp(sp);
				sp.backup();
				target = new (nothrow) MCChunk(False);
				MCerrorlock++;
				if (target->parse(sp, False) != PS_NORMAL)
				{
					sp = oldsp;
					delete target;
					target = NULL;
					single = True;
				}
				MCerrorlock--;
			}
		}
		else
			sp . backup();
	}
	if ((mode != PM_CARD && sp . skip_token(SP_FACTOR, TT_OF) == PS_NORMAL) ||
		(mode == PM_CARD && !single && target == NULL))
	{
		target = new (nothrow) MCChunk(False);
		if (target->parse(sp, False) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADTARGET, sp);
			return PS_ERROR;
		}
	}
	if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) == PS_NORMAL)
		mode = PM_SOME;
	if (sp.skip_token(SP_FACTOR, TT_FROM, PT_FROM) == PS_NORMAL)
	{
		if (sp.parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADFROMEXP, sp);
			return PS_ERROR;
		}
		if (sp.skip_token(SP_FACTOR, TT_TO) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_NOTO, sp);
			return PS_ERROR;
		}
		if (sp.parseexp(False, True, &to) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADTOEXP, sp);
			return PS_ERROR;
		}
	}
	if (sp.skip_token(SP_FACTOR, TT_PREP, PT_INTO) == PS_NORMAL)
	{
		sp.skip_token(SP_FACTOR, TT_PROPERTY, P_RECTANGLE);
		if (sp.parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADRECTEXP, sp);
			return PS_ERROR;
		}
	}
	return PS_NORMAL;
}

bool MCPrint::evaluate_src_rect(MCExecContext& ctxt, MCPoint& r_from, MCPoint& r_to)
{
    MCPoint t_from, t_to;
    if (!ctxt . EvalExprAsPoint(from, EE_PRINT_CANTGETCOORD, t_from))
        return false;

    if (!ctxt . EvalExprAsPoint(to, EE_PRINT_CANTGETCOORD, t_to))
        return false;

    r_from = t_from;
    r_to = t_to;

    return true;
}

void MCPrint::exec_ctxt(MCExecContext &ctxt)
{
	if (mode == PM_ANCHOR)
    {
        MCAutoStringRef t_name;
        if (!ctxt . EvalExprAsStringRef(from, EE_DO_BADEXP, &t_name))
            return;
		
		MCPoint t_location;
        if (!ctxt . EvalExprAsPoint(rect, EE_PRINTANCHOR_BADLOCATION, t_location))
            return;

		MCPrintingExecPrintAnchor(ctxt, *t_name, t_location);
	}
	else if (mode == PM_LINK || mode == PM_LINK_ANCHOR || mode == PM_LINK_URL)
	{
		MCPrinterLinkType t_type;
		if (mode == PM_LINK_ANCHOR)
			t_type = kMCPrinterLinkAnchor;
		else if (mode == PM_LINK_URL)
			t_type = kMCPrinterLinkURI;
		else
            t_type = kMCPrinterLinkUnspecified;

		MCAutoStringRef t_target;
        if (!ctxt . EvalExprAsStringRef(to, EE_PRINTLINK_BADDEST, &t_target))
            return;

		MCRectangle t_area;
        if (!ctxt . EvalExprAsRectangle(rect, EE_PRINTLINK_BADAREA, t_area))
            return;

		MCPrintingExecPrintLink(ctxt, (int)t_type, *t_target, t_area);
	}
	else if (mode == PM_BOOKMARK || mode == PM_UNICODE_BOOKMARK)
    {
		MCAutoValueRef t_title;
        if (mode != PM_UNICODE_BOOKMARK)
        {
            if (!ctxt . EvalExprAsStringRef(from, EE_PRINTBOOKMARK_BADTITLE, (MCStringRef&)&t_title))
                return;
        }
        else
        {
            if (!ctxt . EvalExprAsDataRef(from, EE_PRINTBOOKMARK_BADTITLE, (MCDataRef&)&t_title))
                return;
        }

		uint32_t t_level;
        if (!ctxt . EvalOptionalExprAsUInt(to, 0, EE_PRINTBOOKMARK_BADLEVEL, t_level))
            return;

		MCPoint t_location;
        t_location . x = t_location . y = 0;

        MCPoint *t_location_ptr;
        t_location_ptr = &t_location;
        if (!ctxt . EvalOptionalExprAsPoint(rect, t_location_ptr, EE_PRINTBOOKMARK_BADAT, t_location_ptr))
            return;

		bool t_initially_closed;
		t_initially_closed = false;
		if (initial_state != nil)
		{
            MCAutoStringRef t_state;
            if (!ctxt . EvalExprAsStringRef(initial_state, EE_PRINTBOOKMARK_BADINITIAL, &t_state))
                return;

            if (MCStringIsEqualToCString(*t_state, "closed", kMCCompareExact))
				t_initially_closed = true;
            else if (MCStringIsEqualToCString(*t_state, "open", kMCCompareExact))
				t_initially_closed = false;
			else
			{
                ctxt . LegacyThrow(EE_PRINTBOOKMARK_BADINITIAL);
                return;
			}
		}
		else
			t_initially_closed = bookmark_closed;


		if (mode != PM_UNICODE_BOOKMARK)
            MCPrintingExecPrintBookmark(ctxt, (MCStringRef)*t_title, t_location, t_level, t_initially_closed);
		else
            MCPrintingExecPrintUnicodeBookmark(ctxt, (MCDataRef)*t_title, t_location, t_level, t_initially_closed);
	}
	else if (mode == PM_BREAK)
	{
		MCPrintingExecPrintBreak(ctxt);
	}
	else if (mode == PM_MARKED || mode == PM_ALL)
	{
		MCStack *t_stack;
		t_stack = nil;
		if (target != nil)
		{
			MCObject *optr;
			uint32_t parid;
            if (!target -> getobj(ctxt, optr, parid, True)
                    || optr -> gettype() != CT_STACK)
			{
                ctxt . LegacyThrow(EE_PRINT_NOTARGET);
                return;
			}

			t_stack = (MCStack *)optr;
		}

		MCPoint t_area_from, t_area_to;
		if (from != nil &&
                !evaluate_src_rect(ctxt, t_area_from, t_area_to))
            return;

		if (from == nil)
			MCPrintingExecPrintAllCards(ctxt, t_stack, mode == PM_MARKED);
		else
			MCPrintingExecPrintRectOfAllCards(ctxt, t_stack, mode == PM_MARKED, t_area_from, t_area_to);
	}
	else if (mode == PM_CARD)
	{
		MCObject *t_object;
		if (target != NULL)
		{
			uint32_t parid;
            if (!target -> getobj(ctxt, t_object, parid, True))
			{
                ctxt . LegacyThrow(EE_PRINT_NOTARGET);
                return;
			}
			if (t_object -> gettype() != CT_CARD && t_object -> gettype() != CT_STACK)
			{
                ctxt . LegacyThrow(EE_PRINT_NOTACARD);
                return;
			}
		}
		else
			t_object = MCdefaultstackptr -> getcurcard();

		MCPoint t_from, t_to;
		if (from != nil &&
                !evaluate_src_rect(ctxt, t_from, t_to))
            return;

		if (t_object -> gettype() == CT_STACK)
		{
			if (from == nil)
				MCPrintingExecPrintAllCards(ctxt, (MCStack *)t_object, mode == PM_MARKED);
			else
				MCPrintingExecPrintRectOfAllCards(ctxt, (MCStack *)t_object, mode == PM_MARKED, t_from, t_to);
		}
		else if (rect == nil)
		{
			if (from == nil)
				MCPrintingExecPrintCard(ctxt, (MCCard *)t_object);
			else
				MCPrintingExecPrintRectOfCard(ctxt, (MCCard *)t_object, t_from, t_to);
		}
		else
		{
            MCRectangle t_dst_area;
            if (!ctxt . EvalExprAsRectangle(rect, EE_PRINT_CANTGETRECT, t_dst_area))
                return;

			if (from == nil)
				MCPrintingExecPrintCardIntoRect(ctxt, (MCCard *)t_object, t_dst_area);
			else
				MCPrintingExecPrintRectOfCardIntoRect(ctxt, (MCCard *)t_object, t_from, t_to, t_dst_area);
		}
	}
	else if (mode == PM_SOME)
	{
        integer_t t_count;
        if (!ctxt . EvalExprAsInt(target, EE_PRINT_CANTGETCOUNT, t_count))
            return;

		MCPoint t_from, t_to;
		if (from != nil &&
            !evaluate_src_rect(ctxt, t_from, t_to))
            return;

		if (from == nil)
			MCPrintingExecPrintSomeCards(ctxt, t_count);
		else
			MCPrintingExecPrintRectOfSomeCards(ctxt, t_count, t_from, t_to);
    }
}