package org.spiderwiz.tutorial.lesson13.chat;

import java.io.PrintStream;
import java.text.ParseException;
import java.util.Collection;
import java.util.List;
import org.spiderwiz.core.DataObject;
import org.spiderwiz.tutorial.objectLib.ActiveUserQuery;
import org.spiderwiz.tutorial.objectLib.Chat;
import org.spiderwiz.tutorial.objectLib.ChatApp;
import org.spiderwiz.tutorial.objectLib.ChatHistoryQuery;
import org.spiderwiz.tutorial.objectLib.ChatMessage;
import org.spiderwiz.tutorial.objectLib.ChatRoom;
import org.spiderwiz.tutorial.objectLib.Chatter;
import org.spiderwiz.tutorial.objectLib.ConsoleMain;
import org.spiderwiz.tutorial.objectLib.LoginQuery;
import org.spiderwiz.zutils.ZDate;

/**
 * Provides the entry point of the application. Initializes and executes the Spiderwiz framework.
 */
public class ChatMain extends ConsoleMain{
    private static final String ROOT_DIRECTORY = "";
    private static final String APP_NAME = "Chat Room Client";
    private static final String APP_VERSION = "Z13.01";  // Version Z13.01: Lesson 13 modifications

    private static final String JOIN = "!join";         // join a chat room command
    private static final String LEAVE = "!leave";       // leave current chat room command
    private static final String LOGIN = "!login";       // start login procedure
    private static final String LOGOUT = "!logout";     // log the user out
    private static final String REGISTER = "!register"; // start registration procedure
    private static final String HISTORY = "!history";   // print my chat history
    
    private String myName = null;               // The user login name
    private ZDate birthday = null;              // User birth date. Get it when logging in
    private ChatterConsume chatter = null;             // A Chatter object representing the user chatting in a specific room
    private ChatMessage message = null;         // A ChatMessage object for committing chat messages
    private Chat privateMessage = null;         // A Chat object for committing private messages

    /**
     * Class constructor with constant parameters.
     * @param confFileName  configuration file name, provided as a command argument
     */
    public ChatMain(String confFileName) {
        super(ROOT_DIRECTORY, confFileName, APP_NAME, APP_VERSION);
    }
    
    /**
     * @return the class instance as ChatMain type.
     */
    public static ChatMain getInstance() {
        return (ChatMain)ConsoleMain.getInstance();
    }

    /**
     * Application entry point. Instantiate the class and initialize the instance.
     * 
     * @param args the command line arguments. The first argument is used as the configuration file name.
     */
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // Don't do anything if there is no configuration file name
        if (args.length == 0) {
            System.out.println("Configuration file has not been defined");
            return;
        }
        new ChatMain(args[0]).init();
    }

    /**
     * Print user instructions to the console.
     * @return true
     */
    @Override
    protected boolean preStart() {
        System.out.printf(
            "Welcome to the dynamic chat system.n"
                + "To log in type !login.n"
                + "To log out type !logout.n"
                + "To register type !register.n"
                + "To join a chat room or change your current chat room, type "!join <room name>".n"
                + "To leave your chat room, type "!leave".n"
                + "To send a message in the current chat room just type the message "
                + "(a message cannot start with either '>' or '!').n"
                + "To send a private message type '>' followed by name of the user you want to send "
                + "the private message to, followed by ':' for by the message.n"
                + "To print the history of your own messages, type "!history <hours>h" or "!history <days>d"n"
                + "(for instance "!history 3h" to see messages since 3 hours ago and "!history 1d" to see messages since 1 day"
                + " ago).n"
                + "or type just "!history" to see all your messages.n"
                + "To exit type 'exit'.n"
        );
        return true;
    }
    
    /**
     * @return the list of produced objects - Chatter, Chat, ChatMessage and LoginQuery
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{
            ChatApp.ObjectCode,
            Chatter.ObjectCode,
            Chat.ObjectCode,
            ChatMessage.ObjectCode,
            LoginQuery.ObjectCode,
            ChatHistoryQuery.ObjectCode,
            ObjectCodes.EventReport         // Added in Lesson 13
        };
    }

    /**
     * @return the list of consumed objects - ChatRoom, Chatter, Chat, ChatMessage and ActiveUserQuery
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{
            ChatRoom.ObjectCode,
            ChatApp.ObjectCode,
            Chatter.ObjectCode,
            Chat.ObjectCode,
            ChatMessage.ObjectCode,
            ActiveUserQuery.ObjectCode
        };
    }

    /**
     * Add implementation classes to the object factory list of this application.
     * @param factoryList
     */
    @Override
    protected void populateObjectFactory(List<Class<? extends DataObject>> factoryList) {
        super.populateObjectFactory(factoryList);
        factoryList.add(ChatRoomConsume.class);
        factoryList.add(ChatApp.class);
        factoryList.add(ChatterConsume.class);
        factoryList.add(ChatConsume.class);
        factoryList.add(ChatMessageImp.class);
        factoryList.add(LoginQuery.class);
        factoryList.add(ActiveUserQueryReply.class);
        factoryList.add(ChatHistoryQueryInquire.class);
    }

    
    /**
     * Process an input line
     * @param line      the line to be broadcast as a chat message.
     * @return true if processed successfully
     */
    @Override
    protected boolean processConsoleLine(String line) {
        try {
            // If the line starts with '!' this is a command line
            if (line.startsWith("!")) {
                String command[] = line.trim().split("s+", 2);
                switch (command[0].toLowerCase()) {
                case JOIN:
                    // if room name is provided join the room
                    if (command.length > 1)
                        joinRoom(command[1]);
                    break;
                case LEAVE:
                    // If the user is in a room, leave it
                    leaveRoom(null);
                    break;
                case LOGIN:
                    login();
                    break;
                case LOGOUT:
                    logout();
                    break;
                case REGISTER:
                    register();
                    break;
                case HISTORY:
                    if (myName == null)
                        System.out.println("You must log in before requesting history.");
                    else if (!getHistory(command.length < 2 ? null : command[1]))
                        System.out.println("Invalid command argument");
                    break;
                }
                return true;
            }
            
            // If the line starts with '>' split the line on the colon (':') and send the test
            // after the colon as a private message to the user with the name before the colon.
            if (line.startsWith(">")) {
                String cmd[] = line.substring(1).split(":");
                if (cmd.length < 2)
                    return true;
                String destination = findUser(cmd[0]);
                if (destination == null)
                    return true;
                // If didn't do yet, create an orphan Chatter object for sending private messages,
                // then prepare a ChatMessage object for sending private messages
                if (privateMessage == null) {
                    privateMessage = createTopLevelObject(Chat.class, null);
                    privateMessage.setName(myName);
                }
                // Set message and commit to destination
                privateMessage.setMessage(cmd[1]);
                privateMessage.setTime(ZDate.now());
                privateMessage.commit(destination);
                return true;
            }
            
            // If this is a normal message, make sure the user is in a room and broadcast the message
            if (message != null) {
                message.setMessage(line);
                message.setTime(ZDate.now());
                message.commit();
            }
        } catch (Exception ex) {
            sendExceptionMail(ex, "Exception when processing an input line", line, true);
        }
        return true;
    }
    public String getMyName() {
        return myName;
    }

    public ZDate getBirthday() {
        return birthday;
    }
    
    /**
     * Get user name and password and log in.
     * @return a PrintStream object. Not needed by the caller but we use it as a trick to save coding.
     * @throws NoSuchFieldException     If LoginQuery does not define ObjectCode static field.
     * @throws IllegalAccessException   If LoginQuery.ObjectCode is not public.
     */
    private PrintStream login() throws NoSuchFieldException, IllegalAccessException {
        String username;
        String password;

        // Check if already logged in
        if (myName != null)
            return System.out.printf("You are already logged in as %s. To log in with another name log out first.n", myName);
        
        // Create a login query
        LoginQuery query = createQuery(LoginQuery.class);
        while(true) {
            // Get user name
            System.out.printf("(type Enter to exit login)n");
            username = readConsoleLine("User name:");
            if (username.isBlank())
                return exitLogin();
            do {
                // Get password
                password = readConsoleLine("Password:");
                if (password.isBlank())
                    return exitLogin();

                // Post the login query
                query.setNewUser(false);
                query.setName(username);
                query.setPassword(password);
                query.post(5 * ZDate.SECOND);
                
                // If the query did not expire check login results, if it did, repeat.
                if (query.waitForReply()) {
                    switch (query.getResult()) {
                    case OK:
                        myName = query.getName();
                        birthday = query.getBirthday();
                        return System.out.printf("Logged in successfully as %s.n", myName);
                    case NOT_EXISTS:
                        System.out.printf("User %s does not exist. Please try again.n", username);
                        break;
                    case WRONG_PASSWORD:
                        System.out.printf("Password did not match, please try again.n");
                        break;
                    }
                } else
                    return unavailableUserManager();
            } while (query.getResult() == LoginQuery.ResultCode.WRONG_PASSWORD);
        }
    }
    
    /**
     * Log out if already logged in
     */
    private void logout() {
        if (myName == null) {
            System.out.printf("No user is logged in.n");
            return;
        }
        leaveRoom(null);
        System.out.printf("%s is logged out.n", myName);
        myName = null;
        birthday = null;
    }

    private PrintStream register() throws NoSuchFieldException, IllegalAccessException {
        String username;
        String password, password2;

        // Check if already logged in
        if (myName != null)
            return System.out.printf("You are already logged in as %s. To register a new user log out first.n", myName);
        
        // Create a registration query
        LoginQuery query = createQuery(LoginQuery.class);
        while(true) {
            // Get user name
            System.out.printf("(type Enter to exit login)n");
            username = readConsoleLine("User name:");
            if (username.isBlank())
                return exitRegistration();
            do {
                // Get password
                password = readConsoleLine("Password:");
                if (password.isBlank())
                    return exitRegistration();

                // Repeat the password
                password2 = readConsoleLine("Repeat password:");
                if (password2.isBlank())
                    return exitRegistration();
                
                // Check if passwords are equal
                if (password.equals(password2))
                    break;
                System.out.println("Passwords do not match.");
            } while (true);
            
            // Get and parse birth date
            do {
                String s = readConsoleLine("Date of birth (yyyy/mm/dd):");
                if (s.isBlank())
                    return exitRegistration();
                try {
                    birthday = ZDate.parseTime(s, "yyyy/MM/dd", null);
                } catch (ParseException ex) {
                    birthday = null;
                    System.out.printf("Invalid date %s. Please try again.n", s);
                }
            } while (birthday == null);

            // Post the registration query
            query.setNewUser(true);
            query.setName(username);
            query.setPassword(password);
            query.setBirthday(birthday);
            query.post(5 * ZDate.SECOND);

            // If the query did not expire check login results, if it did, repeat.
            if (query.waitForReply()) {
                switch (query.getResult()) {
                case OK:
                    myName = username;
                    return System.out.printf("Registered and logged in successfully as %s.n", myName);
                case EXISTS:
                    System.out.printf("User %s already exista. Please try again with another name.n", username);
                    break;
                }
            } else
                return unavailableUserManager();
        }
    }
    
    /**
     * Print a message when login existed by typing a blank Enter
     * @return a PrintStream object. Not needed by the caller but we use it as a trick to save coding.
     */
    private PrintStream exitLogin() {
        return System.out.printf("Login exitedn");
    }
    
    /**
     * Print a message when registration existed by typing a blank Enter
     * @return a PrintStream object. Not needed by the caller but we use it as a trick to save coding.
     */
    private PrintStream exitRegistration() {
        return System.out.printf("Registration exitedn");
    }
    
    /**
     * Print a message when user management is not available
     * @return a PrintStream object. Not needed by the caller but we use it as a trick to save coding.
     */
    private PrintStream unavailableUserManager() {
        return System.out.printf("No user management entity is available to handle this requestn");
    }
    
    /**
     * Join a room after checking that the room exists, its adult setting matches user configuration,
     * and the user is not already there. If the user is in another room leave that room first.
     * @param room  the new room name
     * @throws NoSuchFieldException     If any of the created data objects does not define ObjectCode static field.
     * @throws IllegalAccessException   If ObjectCode is not public.
     */
    private synchronized void joinRoom(String room) throws NoSuchFieldException, IllegalAccessException {
        // User must be logged in
        if (myName == null) {
            System.out.printf("You must log in before joining a room.n");
            return;
        }
        
        // Check whether room exists and the user is not already in the room
        ChatRoomConsume chatRoom = getRootObject().getChild(ChatRoomConsume.class, room);
        if (chatRoom == null) {
            System.out.printf("Room %s does not existn", room);
            return;
        }

        if (chatter != null && room.equalsIgnoreCase(chatter.getRoomName()))
            return;
        
        // Check if a young chatters is trying to join an adult room
        if (!chatRoom.canJoin(birthday)) {
            System.out.printf("You cannot join room %s because it is only for adultsn", room);
            return;
        }
        
        // Leave current room if any
        leaveRoom(null);
        
        // Join the application to the room
        ChatApp chatApp = chatRoom.createChild(ChatApp.class, getAppUUID().toString());
        
        // Create a Chatter object for the user that joins the specified room
        chatter = chatApp.createChild(ChatterConsume.class, myName);
        chatter.setName(myName);
        chatter.setBirthday(birthday);
        chatter.commit();       // let everybody know I joined the room
        // Prepare a ChatMessage object for sending messages from now on
        message = chatter.createChild(ChatMessage.class, null);
        System.out.printf("Joined room %sn", room);
    }
    
    /**
     * If the user is in the given room, leave it.
     * @param room  the name of the room to be checked if the user is there. If null, leave the current room without checking
     */
    public synchronized void leaveRoom(String room) {
        if (isSameRoom(room)) {
            // Leave the room and let everybody know I did
            DataObject removed = chatter.remove();
            if (removed != null)                    // can be null if the 'chatter' object has already been removed.
                removed.commit();
            
            // Disconnect the application from the room and let every application know it did
            removed = chatter.getParent().remove();
            if (removed != null)
                removed.commit();
            System.out.printf("Left room %sn", chatter.getRoomName());
            chatter = null;
            message = null;
        }
    }
    
    /**
     * Check if the user is in the same room as the parameter
     * @param room  the name of the room to be checked if the user is there. If null, return true
     * @return true if the user in 'room' or 'room' is null
     */
    public synchronized boolean isSameRoom(String room) {
        return chatter != null &&
            (room == null || room.equalsIgnoreCase(chatter.getRoomName()));
    }
    
    /**
     * Get current room name, if any
     * @return if the user is currently in a room return the room name, otherwise return null.
     */
    public synchronized String getCurrentRoom() {
        return chatter == null ? null : chatter.getRoomName();
    }
    
    /**
     * Find the user whose name equals the parameter
     * @param name  user name to look for
     * @return      If a Chatter object for this user found then return the object ID of its grandparent, which is the UUID of the
     *              application that the given user runs, otherwise return null.
     * @throws NoSuchFieldException     If any of the referred data objects does not define ObjectCode static field.
     * @throws IllegalAccessException   If ObjectCode is not public.
     */
    private String findUser(String name) throws NoSuchFieldException, IllegalAccessException {
        FindUserFilter filter = new FindUserFilter(name);
        Collection<Chatter> users = getRootObject().getFilteredChildren(filter);
        // If the returned collection is not empty return the object ID (which is a UUID) of the first,
        // otherwise return null.
        for (Chatter user : users) {
            return user.getParent().getObjectID();
        }
        return null;
    }
    
    /**
     * Execute !history command
     * @param arg   command argument - <n>H or <n>D
     * @return  true if command has been parsed successfully.
     * @throws NoSuchFieldException     If ChatHistoryQuery does not define ObjectCode static field.
     * @throws IllegalAccessException   If ChatHistoryQuery.ObjectCode is not public.
     */
    private boolean getHistory(String arg) throws NoSuchFieldException, IllegalAccessException {
        // Parse the argument and calculate time
        ZDate since = null;
        if (arg != null) {
            arg = arg.trim().toLowerCase();
            int n = Integer.parseInt(arg.substring(0, arg.length() - 1));
            if (n <= 0)
                return false;
            int unit;
            switch (arg.substring(arg.length() - 1)) {
            case "h":
                unit = ZDate.HOUR;
                break;
            case "d":
                unit = ZDate.DAY;
                break;
            default:
                return false;
            }
            since = ZDate.now().add(-n * unit);
        }
        
        // create a query and post it
        ChatHistoryQuery query = createQuery(ChatHistoryQuery.class);
        query.setUsername(myName);
        query.setSince(since);
        query.post(5 * ZDate.SECOND);
        return true;
    }
}

package org.spiderwiz.tutorial.lesson3;

import org.spiderwiz.core.Main;

/**
 * Main class for MyHub. As a hub, we neither produce nor consume any object.
 */
public class HubMain extends Main{
    private static final String ROOT_DIRECTORY = "/tests/MyHub";
    private static final String CONFIG_FILE_NAME = "hub.conf";
    private static final String APP_NAME = "My Hub";
    private static final String APP_VERSION = "Z13.01";  // Version Z13.01: Amend for lesson 13

    public HubMain() {
        super(ROOT_DIRECTORY, CONFIG_FILE_NAME, APP_NAME, APP_VERSION);
    }

    /**
     * @return an empty list as we produce nothing
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{};
    }

    /**
     * @return a list containing ObjectCodes.EventReport because this application can send mails.
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{ObjectCodes.EventReport};
    }
}

[log folder]Logs
[consumer server-1]websocket;ping-rate=30
[producer server-1]websocket;ping-rate=30
[consumer server-2]port=10001
[spideradmin]iciDtSTUFzuD6+kno9TmiZtaFNlQ
[hub mode]yes
[mail system]smtp;server=smtp.gmail.com;user=tester@spiderwiz.org;pwd=dumptrump;port=465;ssl=true
[from address]My Hub Alerts<alert@spiderwiz.org>
[to email]Spiderwiz Administrator<spiderwiz.admin@gmail.com>
[to exception email]Spiderwiz Programmer<spiderwiz.geek@gmail.com>