@page "/expand"
@page "/expand/{messageId}"
@inherits LocalizableComponentBase

<div class="flex w-full h-full flex-col gap-4">

	<section class="block relative w-full h-full neo-inset neo-xs rounded-xl">
		<div class="flex flex-col gap-4 p-4 md:p-5 w-full h-full absolute overflow-y-auto @SUtility.IfTrueThen(TimeSortingType is TimeSortingType.Descending, "flex-col-reverse")">

			@if (IsLoading)
			{
				<p class="flex w-full items-center justify-center gap-2">
					<DLoading Variant="DLoadingVariant.Dots" LabelText="@Localizer["loading"]" />
					@Localizer["loading"]
				</p>
			}
			else if (IsNotFound)
			{
				<p class="w-full text-center text-lg">
					<i class="ion-ios-remove-circle-outline"></i> @Localizer["This message doesn't exist."]
				</p>
			}
			else
			{
				@foreach (var message in Ancestors)
				{
					<Content CssContainer="ml-6 w-auto" IncludeExpand="false" Message="message"
							 OnMessageBoost="async (m) => await OnMessageBoost(m)" OnMessageDelete="async (m) => await OnMessageDelete(m)"
							 OnMessageFavourite="async (m) => await OnMessageFavourite(m)" OnMessageReply="async (m) => await OnMessageReply(m)"
							 OnMessageMediaDownload="async (m) => await OnMessageMediaDownload(m)"
							 OnUserBlock="async (u) => await OnUserBlock(u)" OnUserDirectMessage="async (u) => await OnUserDirectMessage(u)" OnUserSilence="async (u) => await OnUserSilence(u)" />
				}

				<Content Highlighted="true" IncludeExpand="false" Message="CurrentMessage"
						 OnMessageBoost="async (m) => await OnMessageBoost(m)" OnMessageDelete="async (m) => await OnMessageDelete(m)"
							 OnMessageFavourite="async (m) => await OnMessageFavourite(m)" OnMessageReply="async (m) => await OnMessageReply(m)"
							 OnMessageMediaDownload="async (m) => await OnMessageMediaDownload(m)"
							 OnUserBlock="async (u) => await OnUserBlock(u)" OnUserDirectMessage="async (u) => await OnUserDirectMessage(u)" OnUserSilence="async (u) => await OnUserSilence(u)" />

				@foreach (var message in Descendants)
				{
					<Content CssContainer="ml-6 w-auto" IncludeExpand="false" Message="message"
							 OnMessageBoost="async (m) => await OnMessageBoost(m)" OnMessageDelete="async (m) => await OnMessageDelete(m)"
							 OnMessageFavourite="async (m) => await OnMessageFavourite(m)" OnMessageReply="async (m) => await OnMessageReply(m)"
							 OnMessageMediaDownload="async (m) => await OnMessageMediaDownload(m)"
							 OnUserBlock="async (u) => await OnUserBlock(u)" OnUserDirectMessage="async (u) => await OnUserDirectMessage(u)" OnUserSilence="async (u) => await OnUserSilence(u)" />
				}
			}

		</div>
	</section>

</div>

@code {
	[Inject] IStorage DbStorage { get; set; }
	[Inject] ILocalStorageService LocalStorage { get; set; }
	[Inject] IBlazorDownloadFileService BlazorDownloadFileService { get; set; }
	[Inject] MessagesService MessagesService { get; set; }
	[Parameter] public string MessageId { get; set; }

	List<Message> Ancestors { get; set; } = [];
	Message CurrentMessage { get; set; } = new();
	List<Message> Descendants { get; set; } = [];
	bool IsNotFound { get; set; }
	TimeSortingType TimeSortingType { get; set; } = TimeSortingType.Ascending;

	// Parameters rather than initialization: following a link to another message reuses this page.
	protected override async Task OnParametersSetAsync()
	{
		if (string.IsNullOrEmpty(MessageId))
		{
			Navigation.NavigateTo("");
			return;
		}

		IsLoading = true;
		var filters = await LocalStorage.GetItemAsync<ActionBarFilter>(nameof(ActionBarFilter)) ?? new();
		TimeSortingType = filters.TimeSortingType;

		if (CascadingState.IsOffline)
		{
			WhenOnline(LoadData);
			StartOnlinePolling();
			IsLoading = false;
			return;
		}

		await LoadData();
		IsLoading = false;
	}

	// The thread: the message from IndexedDB, the ones around it mock (Faker) until the app reads PrivaPub's context.
	async Task LoadData()
	{
		var message = await DbStorage.GetMessage(MessageId);
		IsNotFound = message is null;
		if (IsNotFound)
			return;

		CurrentMessage = message;
		(Ancestors, Descendants) = Faker.Thread(message);
	}

	async Task OnMessageReply(MessageForm messageForm)
	{
		var result = await MessagesService.SubmitMessage(messageForm, CascadingState.User);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Descendants.Add(result.Data as Message);
	}

	async Task OnMessageBoost(Message message)
	{
		if (message.IsBoostedByCurrentUser)
			return;

		var result = await MessagesService.BoostUnboostMessage(message);
		if (result.IsInvalid)
			Toast.AddResponseError(result);
	}

	async Task OnMessageFavourite(Message message)
	{
		var result = await MessagesService.FavouriteUnfavouriteMessage(message);
		if (result.IsInvalid)
			Toast.AddResponseError(result);
	}

	async Task OnMessageDelete(Message message)
	{
		var result = await MessagesService.DeleteMessage(message);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Toast.AddResponseSuccess(Localizer["Message deleted."]);
		if (message == CurrentMessage)
		{
			Navigation.NavigateTo("");
			return;
		}

		Ancestors.Remove(message);
		Descendants.Remove(message);
	}

	async Task OnMessageMediaDownload(Media media)
	{
		await BlazorDownloadFileService.DownloadFileAsync(media.FileName, media.Blob, media.ContentType);
	}

	async Task OnUserBlock(MessageUser messageUser)
	{
		var result = await MessagesService.BlockUserFromMessage(messageUser);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Toast.AddResponseSuccess(Localizer["{0} blocked.", messageUser.DisplayName]);
	}

	async Task OnUserDirectMessage(Message message)
	{
		var result = await MessagesService.ReplyMessage(message, MessageType.Direct);
		if (result.IsInvalid)
			Toast.AddResponseError(result);
	}

	async Task OnUserSilence(MessageUser messageUser)
	{
		var result = await MessagesService.SilenceUserFromMessage(messageUser);
		if (result.IsInvalid)
		{
			Toast.AddResponseError(result);
			return;
		}

		Toast.AddResponseSuccess(Localizer["{0} muted.", messageUser.DisplayName]);
	}
}