mirai/src/UiState.cpp

/*
 * Mirai. Copyright (C) 2024 Vyn
 * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
 * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
 */

#include "UiState.h"
#include "Utils.h"
#include "appwindow.h"
#include "mirai-core/Day.h"
#include "mirai-core/Mirai.h"
#include "mirai-core/SourceDataProvider.h"
#include "slint.h"
#include "slint_sharedvector.h"
#include "slint_string.h"
#include <algorithm>
#include <bits/chrono.h>
#include <cassert>
#include <charconv>
#include <chrono>
#include <ctime>
#include <format>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <memory>
#include <optional>
#include <ostream>
#include <ranges>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>

UiState::UiState(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance), view_(miraiInstance)
{
	sources_ = std::make_shared<slint::VectorModel<Source>>();
	days_ = std::make_shared<slint::VectorModel<Day>>();
	unscheduledTasks_ = std::make_shared<slint::VectorModel<TaskData>>();
	tags_ = std::make_shared<slint::VectorModel<slint::SharedString>>();
	auto sourcesNames = std::make_shared<slint::MapModel<Source, slint::SharedString>>(
		sources_,
		[&](const Source &a) {
			return a.name;
		}
	);

	mainWindow_->global<Backend>().set_sources(sourcesNames);

	view_.setAllSources();
	view_.update();

	reloadSources();
	reloadTasks();

	setupCallbacks();
}

std::optional<Date> stringToDate(const std::string &dateStr)
{
	using std::operator""sv;

	auto dateSplitView =
		dateStr | std::views::split("-"sv) | std::views::transform([](auto v) -> int {
			int i = 0;
			std::from_chars(v.data(), v.data() + v.size(), i);
			return i;
		});
	std::vector<int> dateSplit{dateSplitView.begin(), dateSplitView.end()};
	if (dateSplit.size() != 3) {
		return std::nullopt;
	}

	auto year = dateSplit[0];
	auto month = dateSplit[1];
	auto day = dateSplit[2];
	return Date{.year = year, .month = month, .day = day};
}

void UiState::setupUtilsCallbacks()
{
	mainWindow_->global<Backend>().on_formatDate([&](const Date &date) {
		std::chrono::year_month_day chronoDate{
			std::chrono::year(date.year),
			std::chrono::month(date.month),
			std::chrono::day(date.day),
		};
		return std::format("{:%B %d}", chronoDate);
	});
}

void UiState::setupCallbacks()
{
	mainWindow_->global<Backend>().on_task_clicked([&](int sourceId, int taskId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto task = source->getTaskById(taskId);
		assert(task);
		task->setChecked(!task->checked());
		// task->getState() == mirai::DONE ? task->markAsUndone() : task->markAsDone();
		miraiInstance_->save();
	});

	mainWindow_->global<Backend>().on_source_clicked([&](int index) {
		// index with value -1 is equal to no selection, aka "All"
		if (index == -1) {
			view_.setAllSources();
		} else {
			view_.removeSources();
			const mirai::Source *source = miraiInstance_->getSourceById(index);
			view_.addSource(*source);
		}
		view_.update();
		reloadSources();
		reloadTasks();
	});

	/*mainWindow_->global<Backend>().on_tag_clicked([&](int index) {*/
	/*const std::string &tag = miraiInstance_->getTags().at(index);*/
	/*if (std::ranges::find(view_.getActiveTagsFilter(), tag) ==*/
	/*view_.getActiveTagsFilter().end()) {*/
	/*view_.addTagFilter(tag);*/
	/*} else {*/
	/*view_.removeTagFilter(tag);*/
	/*}*/
	/*view_.update();*/
	/*reloadTasks();*/
	/*});*/

	mainWindow_->global<Backend>().on_delete_task_clicked([&](int sourceId, int taskId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto task = source->getTaskById(taskId);
		assert(task);
		source->removeTask(*task);
		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().on_toggle_show_completed_tasks([&] {
		view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().set_sources_selected(sources_);
	mainWindow_->global<Backend>().set_tags(tags_);
	mainWindow_->global<Backend>().set_visible_tasks(days_);

	mainWindow_->global<Backend>().on_saveTask([&](SaveTaskData newTaskData) {
		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
		assert(source);
		auto task = source->getTaskById(newTaskData.id);
		assert(task);
		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
		const auto dayOpt = source->getDayByDate(date);

		if (!dayOpt.has_value()) {
			throw std::runtime_error("Missing auto day creation implementation");
		}

		const auto day = dayOpt.value();

		task->setTitle(std::string(newTaskData.title));
		task->setDay(day);

		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().on_createTask([&](NewTaskData newTaskData) {
		std::optional<mirai::Date> date = std::nullopt;
		if (newTaskData.date.year != 0) {
			date = SlintDateToMiraiDate(newTaskData.date);
		}
		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);

		std::optional<mirai::Event> event = std::nullopt;
		if (newTaskData.eventId >= 0) {
			event = source->getEventById(newTaskData.eventId);
		}

		source->createTask({
			.title = std::string(newTaskData.title),
			.event = event,
			.date = date,
		});

		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().on_delete_event_clicked([&](int sourceId, int eventId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto event = source->getEventById(eventId);
		assert(event.has_value());
		source->removeEvent(event.value());
		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().on_createEvent([&](NewEventParams newEventParams) {
		const Date &date = newEventParams.date;
		const std::string dateStr = SlintDateToStdString(date);
		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);

		source->createEvent({
			.title = std::string(newEventParams.title),
			.date = SlintDateToMiraiDate(newEventParams.date),
			.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
			.endsAt = SlintTimeToMiraiTime(newEventParams.endsAt),
		});
		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});

	mainWindow_->global<Backend>().on_saveEvent([&](SaveEventParams newEventParams) {
		const Date &date = newEventParams.date;
		const std::string dateStr = SlintDateToStdString(date);
		auto source = miraiInstance_->getSourceById(newEventParams.sourceId);
		assert(source);
		auto event = source->getEventById(newEventParams.id);
		assert(event);
		event->setTitle(std::string(newEventParams.title));
		event->setStartTime(SlintTimeToMiraiTime(newEventParams.startsAt));
		event->setEndTime(SlintTimeToMiraiTime(newEventParams.endsAt));

		// TODO we can't change the date of the event for now.

		miraiInstance_->save();
		view_.update();
		reloadTasks();
	});
	setupUtilsCallbacks();
}

std::shared_ptr<slint::VectorModel<slint::SharedString>>
stdToSlintStringVector(const std::vector<std::string> &stdVector)
{
	auto slintVector = std::make_shared<slint::VectorModel<slint::SharedString>>();
	for (const auto &item : stdVector) {
		slintVector->push_back(slint::SharedString(item));
	}
	return slintVector;
}

void UiState::reloadTasks()
{
	days_->clear();
	if (miraiInstance_->getSources().size() == 0) {
		return;
	}
	auto todayDate = mirai::Date(std::chrono::system_clock::now());
	auto dates = view_.getDates();
	auto slintDays = std::make_shared<slint::VectorModel<Day>>();
	for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {
		auto &currentDate = dates.at(dayIndex);
		auto slintEvents = std::make_shared<slint::VectorModel<Event>>();
		auto slintDayTasks = std::make_shared<slint::VectorModel<TaskData>>();
		auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
									std::chrono::sys_days(currentDate.toStdChrono()) -
									std::chrono::sys_days(todayDate.toStdChrono())
		)
									.count();
		slintDays->push_back(
			Day{.date = MiraiDateToSlintDate(currentDate),
				.events = slintEvents,
				.tasks = slintDayTasks,
				.isLate = currentDate < todayDate,
				.isToday = currentDate == todayDate,
				.relativeDaysDiff = static_cast<int>(relativeDaysDiff)}
		);
		// Day's tasks
		const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);
		for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {
			auto &task = tasksForDate.at(taskIndex);
			slintDayTasks->push_back({
				.sourceId = task.sourceId(),
				.id = task.id(),
				.title = slint::SharedString(task.title()),
				.checked = task.checked(),
			});
		}

		// Day's events
		const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
		for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
			auto &currentEvent = eventsForDate.at(eventIndex);
			auto slintTasks = std::make_shared<slint::VectorModel<TaskData>>();
			slintEvents->push_back(Event{
				.sourceId = currentEvent.sourceId(),
				.id = currentEvent.id(),
				.title = slint::SharedString(currentEvent.title()),
				.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
				.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
				.tasks = slintTasks,
			});
			auto eventTasks = currentEvent.queryTasks();
			for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {
				auto &task = eventTasks.at(taskIndex);
				slintTasks->push_back({
					.sourceId = task.sourceId(),
					.id = task.id(),
					.title = slint::SharedString(task.title()),
					.checked = task.checked(),
				});
			}
		}
	}
	days_ = slintDays;
	mainWindow_->global<Backend>().set_visible_tasks(days_);

	auto unscheduledTasksView = view_.getUnscheduledTasks();
	unscheduledTasks_->clear();
	for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {
		auto &task = unscheduledTasksView.at(taskIndex);
		unscheduledTasks_->push_back({
			.sourceId = task.sourceId(),
			.id = task.id(),
			.title = slint::SharedString(task.title()),
			.checked = task.checked(),
		});
	}
	mainWindow_->global<Backend>().set_unscheduled_tasks(unscheduledTasks_);
}

void UiState::reloadSources()
{
	sources_->clear();
	bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
	for (const auto &source : miraiInstance_->getSources()) {
		bool isSourceSelected = view_.isSourceSelected(*source);
		sources_->push_back(
			{.name = slint::SharedString(source->name()),
			 .selected = isSourceSelected && !noSourceSelected}
		);
	}
	mainWindow_->global<Backend>().set_no_source_selected(noSourceSelected);
}

void UiState::run()
{
	mainWindow_->run();
}