#include <iostream></iostream>

#include <vector></vector>

#ifdef _WIN32

#include <windows.h></windows.h>

#endif

#include <glibmm.h></glibmm.h>

#include <gtkmm application.h=""></gtkmm>

#include <synfig general.h=""></synfig>

#include <synfig main.h=""></synfig>

#include <synfig loadcanvas.h=""></synfig>

#include <synfig filesystemnative.h=""></synfig>

#include "visualizationwindow.h"

using namespace synfig;

typedef std::map<string, rendering::renderer::handle=""> RendererMap;</string,>

const char commandname[] = "visualization";

class TestCallback: public ProgressCallback {

public:

	virtual bool task(const String &task)

		{ synfig::info("%s", task.c_str()); return true; }

	virtual bool error(const String &task)

		{ synfig::error("%s", task.c_str()); return true; }

	virtual bool warning(const String &task)

		{ synfig::warning("%s", task.c_str()); return true; }

};

void print_renderers(const RendererMap& renderers) {

	std::cout << "available renderers: " << std::endl;

	for(RendererMap::const_iterator i = renderers.begin(); i != renderers.end(); ++i)

		if (i->second)

			std::cout << "  " << i->first << " - " << i->second->get_name() << std::endl;

}

int main(int argc, char **argv)

{

	//// init

#ifdef _WIN32

	//  Enable standard input/output on Windows

	if (AttachConsole(ATTACH_PARENT_PROCESS)) {

		freopen("CON", "r", stdin);

		freopen("CON", "w", stdout);

		freopen("CON", "w", stderr);

	}

#endif

	Glib::init();

	String binary_path = get_binary_path(argv[0]);

	String base_dir = etl::dirname(binary_path);

	TestCallback callback;

	Main main(base_dir, &callback);

	info("Visualization test");

	// copy args

	std::vector<char*> args(argv, argv + argc);</char*>

	argv = &args.front();

	//// parse command line

	const RendererMap& renderers = rendering::Renderer::get_renderers();

	if (argc < 3) {

		std::cout << std::endl;

		std::cout << "usage: " << std::endl;

		std::cout << "  " << commandname << " <file.sif|file.sifz> <renderer>" << std::endl;</renderer></file.sif|file.sifz>

		std::cout << std::endl;

		print_renderers(renderers);

		return 0;

	}

	const String filename = argv[1];

	info("filename: %s", filename.c_str());

	const String renderer_name = argv[2];

	info("renderer_name: %s", renderer_name.c_str());

	// remove processed args from argv

	args.erase(args.begin() + 1);

	args.erase(args.begin() + 1);

	argc = (int)args.size();

	//// get renderer

	RendererMap::const_iterator ri = renderers.find(renderer_name);

	if (ri == renderers.end() || !ri->second) {

		error("unknown renderer: %s", renderer_name.c_str());

		print_renderers(renderers);

		return 1;

	}

	rendering::Renderer::Handle renderer = ri->second;

	//// get canvas

	String errors, warnings;

	Canvas::Handle canvas = open_canvas_as(

		FileSystemNative::instance()->get_identifier(filename),

		filename,

		errors,

		warnings );

	if (!canvas)

		return 1;

	//// run Gtk::Application

	info("create Gtk::Application");

	Glib::RefPtr<gtk::application> application = Gtk::Application::create(argc, argv);</gtk::application>

	info("create window");

	VisualizationWindow window(canvas, renderer);

	info("run");

	int result = application->run(window);

	if (result) error("Gtk::Application finished with errog code: %d", result);

	info("end");

	return result;

}