/* Copyright 2020-2022, Michele Santullo
 * This file is part of wrenpp.
 *
 * Wrenpp 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 3 of the License, or
 * (at your option) any later version.
 *
 * Wrenpp 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 wrenpp.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "wrenpp/def_configuration.hpp"
#include "wrenpp/vm_fun.hpp"
#include "wrenpp/callback_manager.hpp"
#include "wrenpp/class_manager.hpp"
#include <string_view>
#include <algorithm>
#include <ctime>
#include <memory>
#include <vector>
#include <cstring>
#include <iostream>

namespace {
	constexpr const char g_calendar_src[] =
"foreign class Calendar {" R"script(
	construct new() {}
	foreign static today()
	foreign add_appointment(desc)
	foreign appointment_count()
}
)script";

	constexpr const char g_test_script[] =
R"script(import "calendar" for Calendar
var cale = Calendar.new()
System.print("Today is %(Calendar.today())")
cale.add_appointment("go get a haircut")
System.print("You have %(cale.appointment_count()) appointment(s)")
)script";

	auto today_unique_str() {
		std::time_t now = std::time(nullptr);
		constexpr const std::size_t buff_sz = 1024;
		auto mem(std::make_unique<char[]>(buff_sz));
		const std::size_t sz = std::strftime(mem.get(), buff_sz, "%A %-e %B %Y", std::localtime(&now));
		if (not sz)
			std::strcpy(mem.get(), "n/a");
		return mem;
	}

	class Calendar {
	public:
		Calendar() {
			//std::cout << "Calendar initialized\n";
		}

		~Calendar() {
			try {
				//std::cout << "Calendar destroyed\n";
			}
			catch (...) {
			}
		}

		static void today (wren::VM& vm) {
			vm.set_slot_string(0, today_unique_str().get());
		}

		void add_appointment (std::string&& appointment) {
			m_appointments.push_back(std::move(appointment));
		}

		void print_appointments() const {
			std::cout << "Appointments for " << today_unique_str().get() << ":\n";
			if (m_appointments.empty()) {
				std::cout << "\t[none]\n";
			}
			else {
				for (const auto& app : m_appointments) {
					std::cout << '\t' << app << '\n';
				}
			}
		}

		std::size_t appointment_count() const {
			return m_appointments.size();
		}

	private:
		std::vector<std::string> m_appointments;
	};

	class MyConf : public wren::DefConfiguration {
	public:
		char* load_module_fn(wren::VM* vm, std::string_view module_name) {
			if (module_name == "calendar") {
				constexpr const std::size_t buff_sz = sizeof(g_calendar_src);
				char* const buff = new char[buff_sz];
				std::copy(g_calendar_src, g_calendar_src + buff_sz / sizeof(g_calendar_src[0]), buff);
				return buff;
			}
			return nullptr;
		}

		void load_module_complete_fn(wren::VM*, std::string_view, char* buffer) {
			delete[] buffer;
		}
	};
} //unnamed namespace

int main() {
	typedef wren::ModuleAndName MN;

	MyConf conf;
	wren::VM vm(&conf, nullptr);
	vm.callback_manager().add_callback(true, "calendar", "Calendar", "today()", &Calendar::today)
		.add_callback(false, "calendar", "Calendar", "add_appointment(_)", wren::make_method_bindable<&Calendar::add_appointment>())
		.add_callback(false, "calendar", "Calendar", "appointment_count()", wren::make_method_bindable<&Calendar::appointment_count>());
	vm.class_manager().add_class_maker("calendar", "Calendar", &wren::make_foreign_class<Calendar>);

	vm.interpret("main", g_test_script);

	Calendar* const cale = std::get<0>(wren::variables<Calendar>(vm, MN{"main", "cale"}));
	cale->print_appointments();

	return 0;
}