envoy/src/main/java/envoy/client/Client.java

package envoy.client;

import java.time.Instant;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Response;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;

import envoy.schema.Message;
import envoy.schema.Message.Metadata.MessageState;
import envoy.schema.ObjectFactory;
import envoy.schema.Sync;
import envoy.schema.User;

/**
 * Project: <strong>envoy-client</strong><br>
 * File: <strong>Client.java</strong><br>
 * Created: <strong>28 Sep 2019</strong><br>
 * 
 * @author Kai S. K. Engelbart
 * @author Maximilian K&auml;fer
 * @author Leon Hofmeister
 * @since Envoy 0.1
 */

public class Client {

	private ObjectFactory	objectFactory	= new ObjectFactory();
	private DatatypeFactory	datatypeFactory;
	private Config			config;
	private User			sender, recipient;

	private Sync	unreadMessagesSync	= objectFactory.createSync();
	public Sync		sync				= objectFactory.createSync();
	public Sync		readMessages		= objectFactory.createSync();

	public Client(Config config, String username) {
		this.config = config;
		try {
			datatypeFactory = DatatypeFactory.newInstance();
		} catch (DatatypeConfigurationException e) {
			e.printStackTrace();
		}
		sender = getUser(username);
		System.out.println("ID: " + sender.getID());
	}

	/**
	 * Creates a {@link Message} object serializable to XML.
	 * 
	 * @param textContent The content (text) of the message
	 * @return prepared {@link Message} object
	 */
	public Message createMessage(String textContent) {
		Message.Metadata metaData = objectFactory.createMessageMetadata();
		metaData.setSender(sender.getID());
		metaData.setRecipient(recipient.getID());
		metaData.setState(MessageState.WAITING);
		metaData.setDate(datatypeFactory.newXMLGregorianCalendar(Instant.now().toString()));

		Message.Content content = objectFactory.createMessageContent();
		content.setType("text");
		content.setText(textContent);

		Message message = objectFactory.createMessage();
		message.setMetadata(metaData);
		message.getContent().add(content);

		return message;
	}
	
	/**
	 * Returns a {@link Sync} with all users on the server.
	 * @return Sync - List of all users on the server.
	 * @since Envoy v0.1-alpha
	 */
	public Sync getUsersListXml() {
		Sync	sendSync	= objectFactory.createSync();
		User	user		= objectFactory.createUser();
		user.setID(-1);
		sendSync.getUsers().add(user);

		javax.ws.rs.client.Client	client	= ClientBuilder.newClient();
		WebTarget					target	= client.target(String
			.format("%s:%d/envoy-server/rest/sync/syncData?userId=%d", config.getServer(), config.getPort(), 0));

		Response	response		= target.request().post(Entity.entity(sendSync, "application/xml"));
		Sync		returnSendSync	= response.readEntity(Sync.class);
		response.close();
		client.close();
		return returnSendSync;

	}

	/**
	 * Returns a {@link User} with a specific name by name.
	 * 
	 * @param name - the name of the {@link User}
	 * @return a {@link User} with the specified name
	 * @since Envoy v0.1-alpha
	 */
	private User getUser(String name) {
		Sync	senderSync	= objectFactory.createSync();
		User	user		= objectFactory.createUser();
		user.setName(name);
		senderSync.getUsers().add(user);

		javax.ws.rs.client.Client	client	= ClientBuilder.newClient();
		WebTarget					target	= client.target(String
			.format("%s:%d/envoy-server/rest/sync/syncData?userId=%d", config.getServer(), config.getPort(), 0));

		Response	response			= target.request().post(Entity.entity(senderSync, "application/xml"));
		User		returnSender		= objectFactory.createUser();
		Sync		returnSenderSync	= response.readEntity(Sync.class);
		if (returnSenderSync.getUsers().size() == 1) {
			returnSender = returnSenderSync.getUsers().get(0);
		} else {
			System.out.println("ERROR exiting...");
		}
		response.close();
		client.close();
		return returnSender;
	}

	/**
	 * Sends the "sync" Sync Object to the server and gets a "returnSync" Sync
	 * Object as response. <br>
	 * It is also used to get the own sender at the start of the client 
	 * (Client sends "sync" Sync Object with single user in it(name: the name entered at login, id: 0, UserStatus:null))<br>
	 *  and to get a complete list of all users saved on the server. 
	 * (Client sends "sync" Sync Object with single user in it(name: "" (empty), id: -1, UserStatus:null)) <br>
	 * This method also processes the response Sync Object. <br>
	 * It sorts its users and messages by specific variables and does certain things
	 * with them. <br>
	 * <br>
	 * Messages: <br>
	 * -State SENT: 					Update Local message(s) with State WAITING (add Message ID and
	 * 									change State to SENT). (server sends these informations to the client if
	 * 									message(s) with State WAITING were successfully sent to the server)<br>
	 * -State RECEIVED, SenderID != 0: 	Adds the unread Messages returned from the
	 * 									server in the latest sync to the "unreadMessagesSync" Sync Object. <br>
	 * -State RECEIVED, SenderID == 0: 	Update message(s) in localDB to state RECEIVED.
	 * 									(server sends these informations to the client if the other client received
	 * 									the message(s).) <br>
	 * -State READ:						Update message(s) in the LocalDB to state READ. (server sends these informations to the client if the other client read
	 * 									the message(s).) <br>
	 * <br>
	 * Users: <br>
	 * Updating UserStatus of all users in LocalDB. (Server sends all users with their updated UserStatus to the client.) <br>						
	 * 
	 * @param userId
	 * @param localDB
	 * @since Envoy v0.1-alpha
	 */
	public void sendSync(long userId, LocalDB localDB) {
		new Thread(() -> {
			// Print sync XML to console
			JAXBContext jc;
			try {
				jc = JAXBContext.newInstance("envoy.schema");
				Marshaller m = jc.createMarshaller();
				m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
				m.marshal(sync, System.out);
			} catch (JAXBException e) {
				e.printStackTrace();
			}
			addWaitingMessagesToSync(localDB);

			getSentStateMessagesFromLocalDB(localDB);
			for (int i = 0; i < readMessages.getMessages().size(); i++) {
				sync.getMessages().add(readMessages.getMessages().get(i));
			}
			readMessages.getMessages().clear();

			// Send sync
			javax.ws.rs.client.Client	client	= ClientBuilder.newClient();
			WebTarget					target	= client
				.target(String.format("%s:%d/envoy-server/rest/sync/syncData?userId=%d",
						config.getServer(),
						config.getPort(),
						userId));

			Response response = target.request().post(Entity.entity(sync, "application/xml"));

			Sync returnSync = response.readEntity(Sync.class);
			if (returnSync.getMessages().size() != 0) {
				System.out.println("Message ID: " + returnSync.getMessages().get(0).getMetadata().getMessageId());
			}

			for (int i = 0; i < returnSync.getMessages().size(); i++) {

				// Print sync XML to console
				JAXBContext jc2;
				try {
					jc2 = JAXBContext.newInstance("envoy.schema");
					Marshaller m = jc2.createMarshaller();
					m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
					m.marshal(returnSync, System.out);
				} catch (JAXBException e) {
					e.printStackTrace();
				}

				if (returnSync.getMessages().get(i).getMetadata().getMessageId() != 0
						&& returnSync.getMessages().get(i).getMetadata().getState() == MessageState.SENT) {
					// Update Local Messages with State WAITING (add Message ID and change State to
					// SENT)
					for (int j = 0; j < sync.getMessages().size(); j++) {
						if (j == i) {
							sync.getMessages()
								.get(j)
								.getMetadata()
								.setMessageId(returnSync.getMessages().get(j).getMetadata().getMessageId());
							sync.getMessages()
								.get(j)
								.getMetadata()
								.setState(returnSync.getMessages().get(j).getMetadata().getState());
						}

					}

				}
				if (returnSync.getMessages().get(i).getMetadata().getMessageId() != 0
						&& returnSync.getMessages().get(i).getMetadata().getSender() != 0
						&& returnSync.getMessages().get(i).getMetadata().getState() == MessageState.RECEIVED) {
					// these are the unread Messages from the server
					unreadMessagesSync.getMessages().add(returnSync.getMessages().get(i));

				}

				if (returnSync.getMessages().get(i).getMetadata().getMessageId() != 0
						&& returnSync.getMessages().get(i).getMetadata().getSender() == 0
						&& returnSync.getMessages().get(i).getMetadata().getState() == MessageState.RECEIVED) {
					// Update Messages in localDB to state RECEIVED
					for (int j = 0; j < localDB.getChats().size(); j++) {
						if (localDB.getChats().get(j).getRecipient().getID() == returnSync.getMessages()
							.get(i)
							.getMetadata()
							.getRecipient()) {
							for (int k = 0; k < localDB.getChats().get(j).getModel().getSize(); k++) {
								if (localDB.getChats()
									.get(j)
									.getModel()
									.get(k)
									.getMetadata()
									.getMessageId() == returnSync.getMessages().get(i).getMetadata().getMessageId()) {
									// Update Message in LocalDB
									localDB.getChats()
										.get(j)
										.getModel()
										.get(k)
										.getMetadata()
										.setState(returnSync.getMessages().get(j).getMetadata().getState());
								}
							}
						}
					}

				}

				if (returnSync.getMessages().get(i).getMetadata().getMessageId() != 0
						&& returnSync.getMessages().get(i).getMetadata().getState() == MessageState.READ) {
					// Update local Messages to state READ
					System.out
						.println("Message with ID: " + returnSync.getMessages().get(i).getMetadata().getMessageId()
								+ "was initialized to be set to READ in localDB.");
					for (int j = 0; j < localDB.getChats().size(); j++) {
						if (localDB.getChats().get(j).getRecipient().getID() == returnSync.getMessages()
							.get(i)
							.getMetadata()
							.getRecipient()) {
							System.out.println(
									"Chat with: " + localDB.getChats().get(j).getRecipient().getID() + "was selected.");
							for (int k = 0; k < localDB.getChats().get(j).getModel().getSize(); k++) {
								if (localDB.getChats()
									.get(j)
									.getModel()
									.get(k)
									.getMetadata()
									.getMessageId() == returnSync.getMessages().get(i).getMetadata().getMessageId()) {
									System.out.println("Message with ID: "
											+ localDB.getChats().get(j).getModel().get(k).getMetadata().getMessageId()
											+ "was selected.");
									localDB.getChats()
										.get(j)
										.getModel()
										.get(k)
										.getMetadata()
										.setState(returnSync.getMessages().get(i).getMetadata().getState());
									System.out.println("Message State is now: " + localDB.getChats()
										.get(j)
										.getModel()
										.get(k)
										.getMetadata()
										.getState()
										.toString());
								}
							}
						}
					}

				}
			}

			// Updating UserStatus of all Users in LocalDB
			for (int j = 0; j < returnSync.getUsers().size(); j++) {
				for (int k = 0; k < localDB.getChats().size(); k++) {
					if (localDB.getChats().get(k).getRecipient().getID() == returnSync.getUsers().get(j).getID()) {

						localDB.getChats().get(k).getRecipient().setStatus(returnSync.getUsers().get(j).getStatus());
						System.out.println(localDB.getChats().get(k).getRecipient().getStatus().toString());
					}
				}
			}

			System.out.println("Response code: " + response.getStatus());

			response.close();
			client.close();
			sync.getMessages().clear();
			sync.getUsers().clear();

		}).start();
		System.out.println(sync.getMessages().size());

	}

	/**
	 * Adds a message to the "sync" Sync object.
	 * 
	 * @param message
	 * @since Envoy v0.1-alpha
	 */
	public void addMessageToSync(Message message) { sync.getMessages().add(message); }

	/**
	 * Adds a user to the "sync" Sync object.
	 * 
	 * @param user
	 * @since Envoy v0.1-alpha
	 */
	public void addUserToSync(User user) { sync.getUsers().add(user); }

	/**
	 * Adds the unread Messages returned from the server in the latest sync to the
	 * right chats in the LocalDB.
	 * 
	 * @param localDB
	 * @since Envoy v0.1-alpha
	 */
	public void addUnreadMessagesToLocalDB(LocalDB localDB) {
		Sync unreadMessages = unreadMessagesSync;
		for (int i = 0; i < unreadMessages.getMessages().size(); i++)
			for (int j = 0; j < localDB.getChats().size(); j++)
				if (localDB.getChats().get(j).getRecipient().getID() == unreadMessages.getMessages()
					.get(i)
					.getMetadata()
					.getSender()) {
					localDB.getChats().get(j).appendMessage(unreadMessages.getMessages().get(i));
				}
	}

	/**
	 * Gets all Messages with state SENT from the LocalDB and adds them to the
	 * "sync" Sync object.
	 * 
	 * @param localDB
	 * @since Envoy v0.1-alpha
	 */
	public void getSentStateMessagesFromLocalDB(LocalDB localDB) {
		for (int i = 0; i < localDB.getChats().size(); i++) {
			for (int j = 0; j < localDB.getChats().get(i).getModel().getSize(); j++) {
				if (localDB.getChats().get(i).getModel().get(j).getMetadata().getState() == MessageState.SENT) {
					addMessageToSync(localDB.getChats().get(i).getModel().get(j));
				}
			}
		}
	}

	/**
	 * Changes all Messages with State RECEIVED of a specific chat to State READ.
	 * <br>
	 * Adds these Messages to the "readMessages" Sync object.
	 * 
	 * @param currentChat
	 * @since Envoy v0.1-alpha
	 */
	public void setMessagesToRead(Chat currentChat) {
		for (int j = 0; j < currentChat.getModel().getSize(); j++) {
			if (currentChat.getModel().get(j).getMetadata().getRecipient() != currentChat.getRecipient().getID()) {
				if (currentChat.getModel().get(j).getMetadata().getState() == MessageState.RECEIVED) {
					currentChat.getModel().get(j).getMetadata().setState(MessageState.READ);
					readMessages.getMessages().add(currentChat.getModel().get(j));
				}
			}
		}
	}

	/**
	 * Adds a Message with State WAITING to a specific chat in the LocalDB.
	 * 
	 * @param message
	 * @param currentChat
	 * @since Envoy v0.1-alpha
	 */
	public void addWaitingMessageToLocalDB(Message message, Chat currentChat) { currentChat.appendMessage(message); }

	/**
	 * Adds all Messages with State WAITING from the LocalDB to the Sync.
	 * 
	 * @param localDB
	 * @since Envoy v0.1-alpha
	 */
	public void addWaitingMessagesToSync(LocalDB localDB) {
		for (int i = 0; i < localDB.getChats().size(); i++) {
			for (int j = 0; j < localDB.getChats().get(i).getModel().getSize(); j++) {
				if (localDB.getChats().get(i).getModel().get(j).getMetadata().getState() == MessageState.WAITING) {
					// addMessageToSync(localDB.getChats().get(i).getModel().get(j));
					System.out.println("Got Waiting Message");
					sync.getMessages().add(0, localDB.getChats().get(i).getModel().get(j));
				}
			}
		}
	}

	/**
	 * @return the sender object that represents this client.
	 * @since Envoy v0.1-alpha
	 */
	public User getSender() { return sender; }

	/**
	 * @return the current recipient of the current chat.
	 * @since Envoy v0.1-alpha
	 */
	public User getRecipient() { return recipient; }

	/**
	 * Sets the recipient.
	 * 
	 * @param recipient
	 * @since Envoy v0.1-alpha
	 */
	public void setRecipient(User recipient) { this.recipient = recipient; }

	/**
	 * @return boolean weather the recipient is currently set.
	 * @since Envoy v0.1-alpha
	 */
	public boolean hasRecipient() { return recipient != null; }

	/**
	 * Clears the "unreadMessagesSync" Sync object.
	 * 
	 * @since Envoy v0.1-alpha
	 */
	public void clearUnreadMessagesSync() { unreadMessagesSync.getMessages().clear(); }
}