GCDC-Server/src/main/java/io/github/norbipeti/gcdc/service/DiscordService.java

package io.github.norbipeti.gcdc.service;

import discord4j.core.DiscordClient;
import discord4j.core.DiscordClientBuilder;
import discord4j.core.event.domain.message.MessageCreateEvent;
import discord4j.core.object.entity.GuildMessageChannel;
import discord4j.core.object.entity.Member;
import discord4j.core.object.util.Snowflake;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.async.DeferredResult;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.awt.*;
import java.util.HashMap;
import java.util.Map;

@Component
public class DiscordService {
	private DiscordClient client;
	@Value("${discord.token}")
	private String token;

	@PostConstruct
	public void init() {
		this.client = new DiscordClientBuilder(token).build();
		client.getEventDispatcher().on(MessageCreateEvent.class).subscribe(event -> {
			if (event.getMember().isEmpty() || event.getMessage().getContent().isEmpty())
				return;
			var req = requests.remove(event.getMessage().getChannelId().asLong());
			if (req == null) return;
			var msg = event.getMember().map(member -> Map.of("username", member.getDisplayName(),
					"message", event.getMessage().getContent().orElse("")));
			msg.ifPresent(req::setResult);
		});
		client.login().subscribe();
	}

	public DeferredResult<Map<String, String>> sendMessage(long channel, long user, String message) {
		var result = new DeferredResult<Map<String, String>>();
		client.getChannelById(Snowflake.of(channel)).cast(GuildMessageChannel.class)
				.flatMap(ch -> getUsername(user, ch)
						.flatMap(name -> ch.createEmbed(ecs -> ecs.setAuthor(name, null, null)
								.setColor(Color.BLUE).setDescription(message)).map(msg -> name)))
				.doOnError(result::setErrorResult)
				.subscribe(name -> result.setResult(Map.of("response", "OK", "username", name)));
		return result;
	}

	private final HashMap<Long, DeferredResult<Map<String, String>>> requests = new HashMap<>();

	public DeferredResult<Map<String, String>> getMessage(long channel) {
		var result = new DeferredResult<Map<String, String>>(120000L);
		requests.put(channel, result);
		return result;
	}

	private Mono<String> getUsername(long user, GuildMessageChannel channel) {
		return client.getUserById(Snowflake.of(user)).flatMap(u -> u.asMember(channel.getGuildId()))
				.map(Member::getDisplayName);
	}
}