/*
 * 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 "AppWindow.h"
#include "../../SeleniteSetup.h"
#include "../../shared/Utils.h"
#include "mirai-core/DateTime.h"
#include "mirai-core/Event.h"
#include "mirai-core/MarkdownDataProvider.h"
#include "mirai-core/Mirai.h"
#include "mirai-core/Source.h"
#include "selenite/palette.h"
#include "slint_color.h"
#include "slint_models.h"
#include "slint_string.h"
#include "ui.h"
#include <algorithm>
#include <bits/chrono.h>
#include <cassert>
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <memory>
#include <optional>
#include <print>
#include <ranges>
#include <string>
#include <string_view>
#include <vector>

AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance)
{
	_sidebar_view = ui::SidebarView();
	_calendar_view = ui::CalendarView();
	_tasks_view = ui::TasksView();
	/*auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(*/
	/*sources_, [&](const ui::Source &a) {*/
	/*return a.name;*/
	/*}*/
	/*);*/

	const auto palettePath = std::string(getenv("HOME")) + "/.config/evalyte/theme.json";
	const auto palette = selenite::parseJson(palettePath);
	if (palette.has_value()) {
		std::println(std::cerr, "Warning, no {} found", palettePath);
		setSelenitePalette(mainWindow_->global<ui::Palette>(), palette.value());
	}

	bindSlintUtils(mainWindow_->global<ui::Utils>());

	models().set_sidebar_view(_sidebar_view);
	models().set_calendar_view(_calendar_view);
	models().set_tasks_view(_tasks_view);

	show_all_sources();
	update_views();
	/*view_.setAllSources();*/
	/*view_.update();*/

	reloadSources();
	reloadTasks();

	setupCallbacks();
}

std::optional<ui::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 ui::Date{.year = year, .month = month, .day = day};
}

void AppWindow::setupCallbacks()
{
	models().on_get_source_id_from_name([&](slint::SharedString name) {
		auto source = miraiInstance_->getSourceByName(std::string(name));
		assert(source);
		return source->id;
	});

	models().on_get_source_name_from_id([&](int sourceId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		return slint::SharedString(source->name());
	});

	models().on_get_source_color_from_id_as_hex([&](int sourceId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		return slint::SharedString(source->color());
	});

	models().on_get_source_color_from_id_as_color([&](int sourceId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto color = selenite::hexStringToColor(source->color());
		return slint::Color::from_rgb_uint8(color.r, color.g, color.b);
	});

	models().on_get_source_path_from_id([&](int sourceId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		mirai::markdown_data_provider *sourceProvider =
			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
		return slint::SharedString(sourceProvider->path());
	});

	miraiInstance_->onSourceAdded([&](mirai::source *source) { refreshModels(); });
	miraiInstance_->onSourceEdited([&](mirai::source *source) { refreshModels(); });
	miraiInstance_->onSourceDeleted([&](int id) { refreshModels(); });

	actions().on_task_clicked([&](int sourceId, int taskId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto task = source->get_task_by_id(taskId);
		assert(task);
		task->set_checked(!task->checked());
		miraiInstance_->save();
		update_views();
		// view_.update();
		reloadTasks();
	});

	actions().on_source_clicked([&](int index) {
		const mirai::source *const source = miraiInstance_->getSourceById(index);
		assert(source != nullptr);
		if (should_show_source(*source)) {
			hide_source(*source);
		} else {
			show_source(*source);
		}

		update_views();
	});

	actions().on_add_source([&](slint::SharedString name, slint::SharedString path) {
		std::unique_ptr<mirai::data_provider> file =
			std::make_unique<mirai::markdown_data_provider>(std::string(path));
		miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file));
	});

	actions().on_edit_source([&](int sourceId, slint::SharedString name, slint::SharedString color,
								 slint::SharedString path) {
		miraiInstance_->editSource(
			sourceId, std::string(name), std::string(color), std::string(path)
		);
	});

	actions().on_delete_task_clicked([&](int sourceId, int taskId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto task = source->get_task_by_id(taskId);
		assert(task);
		source->remove_task(*task);
		miraiInstance_->save();
		// view_.update();
		update_views();
		reloadTasks();
	});

	actions().on_toggle_show_completed_tasks([&] {
		// view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
		if (should_hide_completed_tasks()) {
			show_completed_tasks();
		} else {
			hide_completed_tasks();
		}
		// view_.update();
		update_views();
		reloadTasks();
	});

	actions().on_save_task([&](ui::SaveTaskData newTaskData) {
		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
		assert(source);
		auto task = source->get_task_by_id(newTaskData.id);
		assert(task.has_value());
		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
		// const auto dayOpt = source->get_day_by_date(date);
		task->set_title(std::string(newTaskData.title));

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

	actions().on_create_task([&](ui::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->get_event_by_id(newTaskData.eventId);
		}

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

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

	actions().on_delete_event([&](int sourceId, int eventId) {
		auto source = miraiInstance_->getSourceById(sourceId);
		assert(source);
		auto event = source->get_event_by_id(eventId);
		assert(event.has_value());
		source->remove_event(event.value());
		miraiInstance_->save();
		// view_.update();
		update_views();
		reloadTasks();
	});

	actions().on_create_event([&](ui::CreateEventParams newEventParams) {
		const ui::Date &date = newEventParams.date;
		const std::string dateStr = SlintDateToStdString(date);
		auto source = miraiInstance_->getSourceById(newEventParams.source_id);

		source->create_event({
			.title = std::string(newEventParams.title),
			.date = SlintDateToMiraiDate(newEventParams.date),
			.starts_at = SlintTimeToMiraiTime(newEventParams.starts_at),
			.ends_at = SlintTimeToMiraiTime(newEventParams.ends_at),
		});
		miraiInstance_->save();
		update_views();
	});
}

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 AppWindow::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<ui::Day>>();*/
	/*for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {*/
	/*auto &currentDate = dates.at(dayIndex);*/
	/*auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();*/
	/*auto slintDayTasks = std::make_shared<slint::VectorModel<ui::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(*/
	/*ui::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(),*/
	/*.eventId = -1,*/
	/*.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<ui::TaskData>>();*/
	/*slintEvents->push_back(*/
	/*ui::Event{*/
	/*.sourceId = currentEvent.source_id(),*/
	/*.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(),*/
	/*.eventId = currentEvent.id(),*/
	/*.id = task.id(),*/
	/*.title = slint::SharedString(task.title()),*/
	/*.checked = task.checked(),*/
	/*});*/
	/*}*/
	/*}*/
	/*}*/
	/*days_ = slintDays;*/
	/*models().set_days(days_);*/

	/*auto unscheduledTasksView = view_.getUnscheduledTasks();*/
	/*unscheduledTasks_->clear();*/
	/*for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {*/
	/*auto &task = unscheduledTasksView.at(taskIndex);*/
	/*const auto &source = miraiInstance_->getSourceById(task.sourceId());*/
	/*std::println("request name for source id {} : {}", task.sourceId(), source->name());*/
	/*unscheduledTasks_->push_back({*/
	/*.sourceId = task.sourceId(),*/
	/*.eventId = -1,*/
	/*.id = task.id(),*/
	/*.title = slint::SharedString(task.title()),*/
	/*.checked = task.checked(),*/
	/*});*/
	/*}*/
	/*models().set_unscheduled_tasks(unscheduledTasks_);*/

	/*calendar_->clear();*/
	/*for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {*/
	/*std::chrono::year_month_day nextDate =*/
	/*std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +*/
	/*std::chrono::days{dayIndex};*/
	/*auto currentDate = mirai::Date{nextDate};*/
	/*auto events = view_.getEventsForDate(currentDate);*/
	/*auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();*/
	/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
	/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
	/*std::chrono::sys_days(todayDate.toStdChrono())*/
	/*)*/
	/*.count();*/
	/*if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {*/
	/*continue;*/
	/*}*/
	/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
	/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
	/*auto &currentEvent = eventsForDate.at(eventIndex);*/
	/*slintEvents->push_back(*/
	/*ui::CalendarDayEvent{*/
	/*.sourceId = currentEvent.source_id(),*/
	/*.id = currentEvent.id(),*/
	/*.title = slint::SharedString(currentEvent.title()),*/
	/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
	/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
	/*}*/
	/*);*/
	/*}*/

	/*auto calendarDay = ui::CalendarDay{*/
	/*.events = slintEvents,*/
	/*.date = MiraiDateToSlintDate(currentDate),*/
	/*.header = slint::SharedString(*/
	/*capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))*/
	/*)*/
	/*};*/
	/*calendar_->push_back(calendarDay);*/
	/*}*/
}

void AppWindow::reloadSources()
{
	/*sources_->clear();*/
	/*bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();*/
	/*for (const auto &source : miraiInstance_->getSources()) {*/
	/*bool isSourceSelected = view_.isSourceSelected(*source);*/
	/*mirai::markdown_data_provider *sourceProvider =*/
	/*dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());*/
	/*sources_->push_back(*/
	/*{.id = source->id,*/
	/*.name = slint::SharedString(source->name()),*/
	/*.selected = isSourceSelected && !noSourceSelected,*/
	/*.path = slint::SharedString(sourceProvider->path())}*/
	/*);*/
	/*}*/
	/*models().set_no_source_selected(noSourceSelected);*/
}

void AppWindow::refreshModels()
{
	show_all_sources();
	update_views();
}

void AppWindow::update_views()
{
	update_sidebar_view();
	update_calendar_view();
	update_tasks_view();
	update_available_sources();
}

void AppWindow::update_available_sources()
{
	const auto &sources = miraiInstance_->getSources();
	auto available_sources = std::make_shared<slint::VectorModel<ui::AvailableSource>>();
	auto available_sources_strings = std::make_shared<slint::VectorModel<slint::SharedString>>();
	for (auto &source : sources) {
		mirai::markdown_data_provider *sourceProvider =
			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
		const auto color =
			selenite::hexStringToColor(miraiInstance_->getSourceById(source->id)->color());
		auto source_color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);

		available_sources->push_back(
			{.id = source->id, .name = slint::SharedString(source->name()), .color = source_color}
		);
		available_sources_strings->push_back(slint::SharedString(source->name()));
	}

	models().set_available_sources(available_sources);
	models().set_available_sources_strings(available_sources_strings);
};

void AppWindow::update_sidebar_view()
{
	const auto &sources = miraiInstance_->getSources();

	auto new_sources = std::make_shared<slint::VectorModel<ui::SidebarViewSources>>();
	for (auto &source : sources) {
		mirai::markdown_data_provider *sourceProvider =
			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
		const auto color =
			selenite::hexStringToColor(miraiInstance_->getSourceById(source->id)->color());
		auto source_color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);
		new_sources->push_back({
			.id = source->id,
			.name = slint::SharedString(source->name()),
			.color = source_color,
			.active = _source_filters.contains(source->id) && _source_filters.at(source->id),
		});
	}

	_sidebar_view.sources = new_sources;
	_sidebar_view.all_active = true; // TESTING
	_sidebar_view.active_view = ui::SidebarViewActiveTab::Calendar;
	models().set_sidebar_view(_sidebar_view);
}

std::vector<mirai::Event>
merge_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
{
	std::vector<mirai::Event> all_events;
	for (auto &source : sources) {
		const auto &events = source->get_events();
		all_events.insert(all_events.end(), events.begin(), events.end());
	}
	return all_events;
}

std::vector<mirai::Event>
get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
{
	auto filtered_events = events | std::ranges::views::filter([&](const mirai::Event &event) {
							   return event.date() == date;
						   });
	return std::ranges::to<std::vector>(filtered_events);
}

void AppWindow::update_calendar_view()
{
	auto today = mirai::Date(std::chrono::system_clock::now());
	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::CalendarViewDate>>();

	auto &sources = miraiInstance_->getSources();
	auto all_events = merge_all_events_from_sources(sources);

	for (int day_index = 0; day_index < 7; ++day_index) {
		std::chrono::year_month_day next_date =
			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
			+ std::chrono::days{day_index};
		auto current_date = mirai::Date{next_date};
		auto new_slint_events = std::make_shared<slint::VectorModel<ui::CalendarViewEvent>>();
		auto relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
									  std::chrono::sys_days(current_date.toStdChrono())
									  - std::chrono::sys_days(today.toStdChrono())
		)
									  .count();
		if (relative_days_diff < 0 || relative_days_diff >= 7) {
			continue;
		}
		auto events_for_date = get_events_for_date(all_events, current_date);
		for (int event_index = 0; event_index < events_for_date.size(); ++event_index) {
			auto &current_event = events_for_date.at(event_index);
			// TODO directly remove the source instead of this workaround after data layer refacto
			auto source = miraiInstance_->getSourceById(current_event.source_id());
			if (!should_show_source(*source)) {
				continue;
			}
			new_slint_events->push_back(
				ui::CalendarViewEvent{
					.source_id = current_event.source_id(),
					.id = current_event.id(),
					.title = slint::SharedString(current_event.title()),
					.starts_at = MiraiTimeToSlintTime(current_event.starts_at()),
					.ends_at = MiraiTimeToSlintTime(current_event.ends_at()),
				}
			);
		}

		auto new_slint_date = ui::CalendarViewDate{
			.events = new_slint_events,
			.date = MiraiDateToSlintDate(current_date),
			.header = slint::SharedString(
				capitalize(formatDateRelative(MiraiDateToSlintDate(current_date)))
			)
		};
		new_slint_dates->push_back(new_slint_date);
	}
	_calendar_view.dates = new_slint_dates;
	models().set_calendar_view(_calendar_view);
}

std::vector<mirai::Task>
get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
{
	std::vector<mirai::Task> all_tasks;
	for (auto &source : sources) {
		const auto &tasks = source->get_tasks();
		all_tasks.insert(all_tasks.end(), tasks.begin(), tasks.end());
	}
	std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::Task &t1, const mirai::Task &t2) {
		if (!t1.has_due_date() && !t2.has_due_date()) {
			return false;
		}
		if (t1.has_due_date() && !t2.has_due_date()) {
			return true;
		}
		if (!t1.has_due_date() && t2.has_due_date()) {
			return false;
		}
		return t1.due_date() < t2.due_date();
	});
	return all_tasks;
}

struct tasks_source_group {
	int id;
	std::vector<mirai::Task> tasks;
};

struct tasks_date_group {
	std::optional<mirai::Date> date;
	std::vector<tasks_source_group> sources;
};

std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task> &tasks)
{
	if (tasks.size() == 0) {
		return {};
	}

	std::vector<tasks_date_group> dates_group;
	int next_task_index = 0;

	mirai::Task current_task = tasks.at(next_task_index);

	while (next_task_index < tasks.size()) {
		tasks_date_group date_group{.date = current_task.due_date()};

		while (next_task_index < tasks.size() && current_task.due_date() == date_group.date) {
			tasks_source_group source_group{.id = current_task.source_id()};

			while (next_task_index < tasks.size() && current_task.due_date() == date_group.date
				   && current_task.source_id() == source_group.id) {
				source_group.tasks.push_back(current_task);
				next_task_index++;
				if (next_task_index >= tasks.size()) {
					break;
				}
				current_task = tasks.at(next_task_index);
			}
			date_group.sources.push_back(source_group);
		}
		dates_group.push_back(date_group);
	}

	return dates_group;
};

void AppWindow::update_tasks_view()
{
	auto today = mirai::Date(std::chrono::system_clock::now());
	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::TasksViewDate>>();

	auto &sources = miraiInstance_->getSources();
	auto all_tasks_dates = group_tasks_by_date(get_all_tasks_from_sources(sources));

	for (int date_index = 0; date_index < all_tasks_dates.size(); ++date_index) {
		auto &current_date_group = all_tasks_dates.at(date_index);
		auto &current_date = current_date_group.date;
		std::optional<int> relative_days_diff = std::nullopt;
		if (current_date.has_value()) {
			relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
									 std::chrono::sys_days(current_date.value().toStdChrono())
									 - std::chrono::sys_days(today.toStdChrono())
			)
									 .count();
		}

		auto new_slint_sources = std::make_shared<slint::VectorModel<ui::TasksViewSource>>();
		for (auto &source_group : current_date_group.sources) {
			auto new_slint_source = ui::TasksViewSource();
			auto new_slint_tasks = std::make_shared<slint::VectorModel<ui::TasksViewTask>>();
			auto source = miraiInstance_->getSourceById(source_group.id);
			if (!should_show_source(*source)) {
				continue;
			}
			for (auto &task : source_group.tasks) {
				if (task.has_due_date() && task.due_date() < today) {
					continue;
				}
				new_slint_tasks->push_back(
					{.id = task.id(),
					 .source_id = source_group.id,
					 .title = slint::SharedString(task.title()),
					 .checked = task.checked()}
				);
			}
			new_slint_source.tasks = new_slint_tasks;
			new_slint_source.id = source_group.id;
			new_slint_source.name =
				slint::SharedString(miraiInstance_->getSourceById(source_group.id)->name());
			const auto color = selenite::hexStringToColor(source->color());
			new_slint_source.color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);
			if (new_slint_source.tasks->row_count() > 0) {
				new_slint_sources->push_back(new_slint_source);
			}
		}
		auto new_slint_date = ui::TasksViewDate{
			.sources = new_slint_sources,
		};

		if (current_date.has_value()) {
			new_slint_date.due_date = MiraiDateToSlintDate(current_date.value());
			new_slint_date.is_late = current_date.value() < today;
		} else {
			new_slint_date.no_date = true;
		}

		if (new_slint_date.sources->row_count() > 0) {
			new_slint_dates->push_back(new_slint_date);
		}
		_tasks_view.dates = new_slint_dates;
		models().set_tasks_view(_tasks_view);
	}
}

void AppWindow::show_source(const mirai::source &source)
{
	_source_filters.insert_or_assign(source.id, true);
}

void AppWindow::hide_source(const mirai::source &source)
{
	_source_filters.insert_or_assign(source.id, false);
}

bool AppWindow::should_show_source(const mirai::source &source) const
{
	const int source_id = source.id;
	return _source_filters.contains(source_id) && _source_filters.at(source_id);
}

void AppWindow::show_all_sources()
{
	auto &sources = miraiInstance_->getSources();
	for (auto &source : sources) {
		show_source(*source);
	}
}

void AppWindow::hide_all_sources()
{
}

void AppWindow::show_completed_tasks()
{
}

void AppWindow::hide_completed_tasks()
{
}

bool AppWindow::should_hide_completed_tasks() const
{
	return true;
}

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

const ui::AppModels &AppWindow::models()
{
	return mainWindow_->global<ui::AppModels>();
}

const ui::AppActions &AppWindow::actions()
{
	return mainWindow_->global<ui::AppActions>();
}