/**
 * Temple (C) Dylan Knutson, 2013, distributed under the:
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 */

module temple.temple_context;

import temple.temple;
import temple.output_stream;

public import std.variant : Variant;
private import std.array, std.string, std.typetuple;

final class TempleContext
{
private:
	// First hook is called to set the output buffer, the second is to unset it.
	alias TemplateHooks = TypeTuple!(void delegate(OutputStream), void delegate());
	TemplateHooks[0][] pushBuffHooks;
	TemplateHooks[1][] popBuffHooks;

	Variant[string] vars;

	TempleFuncType* yielded_template;


	TemplateHooks[0] getPushBuffHook()
	{
		return pushBuffHooks[$-1];
	}

	TemplateHooks[1] getPopBuffHook()
	{
		return popBuffHooks[$-1];
	}

package:
	/// package
	void __templePopHooks()
	{
		pushBuffHooks.length--;
		popBuffHooks.length--;
	}

	/// package
	void __templePushHooks(TemplateHooks h)
	{
		this.pushBuffHooks ~= h[0];
		this.popBuffHooks ~= h[1];
	}

	/// package
	static AppenderOutputStream __templeRenderWith(TempleFuncType* render_func, TempleContext ctx = null)
	in { assert(render_func !is null); }
	body
	{
		// Ensure a context is always present
		if(ctx is null)
		{
			ctx = new TempleContext();
		}
		// Allocate a buffer and call the render func with it
		auto buff = new AppenderOutputStream();
		render_func(buff, ctx);

		return buff;
	}

public:
	string capture(T...)(void delegate(T) block, T args)
	{
		auto buffer = new AppenderOutputStream();
		scope(exit) { buffer.clear(); }

		// Make the template push to a new, blank buffer
		this.getPushBuffHook()(buffer);

		// Call the block (which resides inside the template, and will
		// now write to `buffer`)
		block(args);

		// Pop `buffer` out of the template
		this.getPopBuffHook()();

		return buffer.data;
	}

	bool isSet(string name)
	{
		return (name in vars && vars[name] != Variant());
	}

	ref Variant var(string name)
	{
		if(name !in vars)
			vars[name] = Variant();

		return vars[name];
	}

	void opIndexAssign(T)(string name, T val) {
		if(name !in vars)
			vars[name] = Variant();

		vars[name] = val;
	}

	VarDispatcher var()
	{
		return VarDispatcher(this);
	}

	Variant opDispatch(string op)() @property
	{
		return vars[op];
	}

	void opDispatch(string op, T)(T other) @property
	{
		vars[op] = other;
	}

	/**
	 * Methods/properties relating to layout support
	 */
	void partial(TempleFuncType* temple_func) @property
	{
		yielded_template = temple_func;
	}

	auto partial() @property
	{
		return yielded_template;
	}

	AppenderOutputStream yield() @property
	{
		auto buff = new AppenderOutputStream();

		if(yielded_template !is null)
		{
			(*yielded_template)(buff, this);
		}

		return buff;
	}
}

private struct VarDispatcher
{
private:
	TempleContext context;

public:
	this(TempleContext context)
	{
		this.context = context;
	}

	ref Variant opDispatch(string op)() @property
	{
		return context.var(op);
	}

	void opDispatch(string op, T)(T other) @property
	{
		context.var(op) = other;
	}
}

unittest
{
	auto context = new TempleContext();
	context.foo = "bar";
	context.bar = 10;

	with(context)
	{
		assert(var.foo == "bar");
		assert(var.bar == 10);

		var.baz = true;
		assert(var.baz == true);
	}
}