envoy/src/main/java/envoy/client/ui/controller/LoginScene.java

package envoy.client.ui.controller;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import java.util.logging.Logger;

import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.scene.control.*;
import javafx.scene.control.Alert.AlertType;

import envoy.client.data.Cache;
import envoy.client.data.ClientConfig;
import envoy.client.data.LocalDB;
import envoy.client.net.Client;
import envoy.client.ui.SceneContext;
import envoy.data.LoginCredentials;
import envoy.data.Message;
import envoy.data.User;
import envoy.data.User.UserStatus;
import envoy.event.EventBus;
import envoy.event.HandshakeRejectionEvent;
import envoy.exception.EnvoyException;
import envoy.util.EnvoyLog;

/**
 * Project: <strong>envoy-client</strong><br>
 * File: <strong>LoginDialog.java</strong><br>
 * Created: <strong>03.04.2020</strong><br>
 *
 * @author Kai S. K. Engelbart
 * @since Envoy Client v0.1-beta
 */
public final class LoginScene {

	@FXML
	private TextField userTextField;

	@FXML
	private PasswordField passwordField;

	@FXML
	private PasswordField repeatPasswordField;

	@FXML
	private Label repeatPasswordLabel;

	@FXML
	private CheckBox registerCheckBox;

	@FXML
	private Label connectionLabel;

	private Client			client;
	private LocalDB			localDB;
	private Cache<Message>	receivedMessageCache;
	private SceneContext	sceneContext;

	private static final Logger			logger		= EnvoyLog.getLogger(LoginScene.class);
	private static final EventBus		eventBus	= EventBus.getInstance();
	private static final ClientConfig	config		= ClientConfig.getInstance();

	@FXML
	private void initialize() {
		connectionLabel.setText("Server: " + config.getServer() + ":" + config.getPort());

		// Show an alert after an unsuccessful handshake
		eventBus.register(HandshakeRejectionEvent.class,
				e -> Platform.runLater(() -> { clearPasswordFields(); new Alert(AlertType.ERROR, e.get()).showAndWait(); }));
	}

	/**
	 * Loads the login dialog using the FXML file {@code LoginDialog.fxml}.
	 *
	 * @param client               the client used to perform the handshake
	 * @param localDB              the local database used for offline login
	 * @param receivedMessageCache the cache storing messages received during
	 *                             the handshake
	 * @param sceneContext         the scene context used to initialize the chat
	 *                             scene
	 * @since Envoy Client v0.1-beta
	 */
	public void initializeData(Client client, LocalDB localDB, Cache<Message> receivedMessageCache, SceneContext sceneContext) {
		this.client					= client;
		this.localDB				= localDB;
		this.receivedMessageCache	= receivedMessageCache;
		this.sceneContext			= sceneContext;

		// Prepare handshake
		localDB.loadIDGenerator();

		// Set initial cursor
		userTextField.requestFocus();

		// Perform automatic login if configured
		if (config.hasLoginCredentials()) performHandshake(config.getLoginCredentials());
	}

	@FXML
	private void loginButtonPressed() {

		// Prevent registration with unequal passwords
		if (registerCheckBox.isSelected() && !passwordField.getText().equals(repeatPasswordField.getText())) {
			clearPasswordFields();
			new Alert(AlertType.ERROR, "The entered password is unequal to the repeated one").showAndWait();
		} else performHandshake(new LoginCredentials(userTextField.getText(), passwordField.getText().toCharArray(), registerCheckBox.isSelected()));
	}

	@FXML
	private void offlineModeButtonPressed() {
		attemptOfflineMode(new LoginCredentials(userTextField.getText(), passwordField.getText().toCharArray(), false));
	}

	@FXML
	private void registerCheckboxChanged() {

		// Make repeat password field and label visible / invisible
		repeatPasswordField.setVisible(registerCheckBox.isSelected());
		repeatPasswordLabel.setVisible(registerCheckBox.isSelected());
		clearPasswordFields();
	}

	@FXML
	private void abortLogin() {
		logger.info("The login process has been cancelled. Exiting...");
		System.exit(0);
	}

	private void performHandshake(LoginCredentials credentials) {
		try {
			client.performHandshake(credentials, receivedMessageCache);
			if (client.isOnline()) {
				client.initReceiver(localDB, receivedMessageCache);
				loadChatScene();
			}
		} catch (IOException | InterruptedException | TimeoutException e) {
			logger.warning("Could not connect to server: " + e);
			logger.finer("Attempting offline mode...");
			attemptOfflineMode(credentials);
		}
	}

	private void attemptOfflineMode(LoginCredentials credentials) {
		try {
			// Try entering offline mode
			localDB.loadUsers();
			final User clientUser = (User) localDB.getUsers().get(credentials.getIdentifier());
			if (clientUser == null) throw new EnvoyException("Could not enter offline mode: user name unknown");
			client.setSender(clientUser);
			new Alert(AlertType.WARNING, "A connection to the server could not be established. Starting in offline mode.").showAndWait();
			loadChatScene();
		} catch (final Exception e) {
			new Alert(AlertType.ERROR, "Client error: " + e).showAndWait();
			System.exit(1);
		}
	}

	private void loadChatScene() {

		// Set client user in local database
		localDB.setUser(client.getSender());

		// Initialize chats in local database
		try {
			localDB.initializeUserStorage();
			localDB.loadUserData();
		} catch (final FileNotFoundException e) {
			// The local database file has not yet been created, probably first login
		} catch (final Exception e) {
			e.printStackTrace();
			new Alert(AlertType.ERROR, "Error while loading local database: " + e + "\nChats will not be stored locally.").showAndWait();
		}

		// Initialize write proxy
		final var writeProxy = client.createWriteProxy(localDB);

		if (client.isOnline()) {

			// Save all users to the local database and flush cache
			localDB.setUsers(client.getUsers());
			writeProxy.flushCache();
		} else
			// Set all contacts to offline mode
			localDB.getUsers().values().stream().filter(User.class::isInstance).map(User.class::cast).forEach(u -> u.setStatus(UserStatus.OFFLINE));

		// Load ChatScene
		sceneContext.pop();
		sceneContext.getStage().setMinHeight(400);
		sceneContext.getStage().setMinWidth(350);
		sceneContext.load(SceneContext.SceneInfo.CHAT_SCENE);
		sceneContext.<ChatScene>getController().initializeData(sceneContext, localDB, client, writeProxy);

		// Relay unread messages from cache
		if (receivedMessageCache != null && client.isOnline()) receivedMessageCache.relay();
	}

	private void clearPasswordFields() {
		passwordField.clear();
		repeatPasswordField.clear();
	}
}