[addressbook-lib.git] / Addressbook / src / org / mxchange / addressbook / manager / contact / ContactManager.java

/*
 * Copyright (C) 2015 Roland Haeder
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.mxchange.addressbook.manager.contact;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.mxchange.addressbook.client.Client;
import org.mxchange.addressbook.contact.Contact;
import org.mxchange.addressbook.database.frontend.contact.ContactDatabaseFrontend;
import org.mxchange.addressbook.database.frontend.contact.ContactWrapper;
import org.mxchange.addressbook.exceptions.UnhandledUserChoiceException;
import org.mxchange.addressbook.manager.BaseManager;

/**
 * A manager for contacts, please note that this implementation loads the whole
 * list into RAM.
 *
 * @author Roland Haeder
 * @version 0.0
 */
public class ContactManager extends BaseManager implements ManageableContact {
    /**
     * Column name list
     */
    private final List<String> columnNames;

    /**
     * A ContactWrapper instance
     */
    private final ContactWrapper contactDatabase;

    /**
     * A list of all contacts
     */
    private final List<Contact> contacts;

    /**
     * Constructor which accepts maxContacts for maximum (initial) contacts and
     * a client instance.
     * 
     * @param maxContacts Maximum allowed contacts
     * @param client Client instance to use
     */
    public ContactManager (final int maxContacts, final Client client) {
        // Always call super constructor first
        super();

        // Set client instance
        this.setClient(client);

        // Init contacts
        this.contacts = new ArrayList<>(maxContacts);

        // Init database connection
        this.contactDatabase = new ContactDatabaseFrontend(this);

        // Initialize list
        this.columnNames = new ArrayList<>(15);

        // And fill it
        this.fillColumnNamesFromBundle();

        // Read all entries
        this.contactDatabase.readAllContacts();

        // Debug message
        //* NOISY-DEBUG: */ this.getLogger().debug("client=" + client);
    }

    /**
     * Adds given Contact instance to list
     *
     * @param contact Contact instance to add
     */
    @Override
    public void addContact (final Contact contact) {
        assert(this.contacts instanceof List) : "this.contacts is not initialized";

        this.contacts.add(contact);
    }

    /**
     * Let the user add a new other address
     */
    @Override
    public void doAddOtherAddress () {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Let the user change address data
     * 
     * @param contact Instance to change data
     * @param client Client instance to call back
     */
    @Override
    public void doChangeAddressData (final Contact contact, final Client client) {
        // First display it again
        client.displayAddressBox(contact);

        // Is it own data?
        if (contact.isOwnContact()) {
            // Deligate to client
            this.getClient().doChangeOwnAddressData(contact);
        } else {
            // Other contact's address data to change
            throw new UnsupportedOperationException("Changing contact entries not finished.");
        }

        // Flush whole list
        this.flush();
    }

    /**
     * Let the user change "name data"
     * 
     * @param contact Instance to change data
     * @param client Client instance to call back
     */
    @Override
    public void doChangeNameData (final Contact contact, final Client client) {
        // First display them again
        client.displayNameBox(contact);

        // Is this own data?
        if (contact.isOwnContact()) {
            // Re-ask own data
            this.getClient().doChangeOwnNameData(contact);
        } else {
            // Then re-ask them ...
            throw new UnsupportedOperationException("Changing contact entries not finished.");
        }

        // Flush whole list
        this.flush();
    }

    /**
     * Let the user change other address
     */
    @Override
    public void doChangeOtherAddress () {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Let the user change other data
     *
     * @param contact Instance to change data
     * @param client Client instance to call back
     * @todo Didn't handle birthday
     */
    @Override
    public void doChangeOtherData (final Contact contact, final Client client) {
        // First display them again
        this.getClient().displayOtherDataBox(contact);

        // Is this own data?
        if (contact.isOwnContact()) {
            // Re-ask own data
            this.getClient().doChangeOwnOtherData(contact);
        } else {
            // Then re-ask them ...
            throw new UnsupportedOperationException("Changing contact entries not finished.");
        }

        // Flush whole list
        this.flush();
    }

    /**
     * Allows the user to change his/her own data
     */
    @Override
    public void doChangeOwnData () {
        /*
         * First check if the user has registered own contact, before that
         * nothing can be changed.
         */
        if (!this.isOwnContactAdded()) {
            // Not added
            this.getClient().outputMessage("Sie haben noch nicht Ihre Daten eingegeben.");
            
            // Skip any below code
            return;
        }
        
        // Instance
        Contact contact = this.getOwnContact();
        
        // It must be found
        assert(contact instanceof Contact);
        
        // Display contact
        contact.show(this.getClient());
        
        try {
            // Ask user what to change
            this.getClient().userChooseChangeContactData(contact);
        } catch (final UnhandledUserChoiceException ex) {
            this.getLogger().catching(ex);
        }
    }

    /**
     * Let the user delete other address
     */
    @Override
    public void doDeleteOtherAddress () {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Asks user for own data
     */
    @Override
    public void doEnterOwnData () {
        // Deligate this call to the client
        Contact contact = this.getClient().doEnterOwnData();

        // Add it to contact "book"
        this.registerContact(contact);
    }

    @Override
    public void doListContacts () {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void doSearchContacts () {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Shuts down this contact manager
     */
    @Override
    public void doShutdown () {
        // Shut down the database layer
        this.getContactDatabase().doShutdown();
    }

    /**
     * Asks the user for his/her cellphone number
     * 
     * @return User's cellphone number
     */
    @Override
    public String enterOwnCellNumber () {
        return this.getClient().enterString(5, 30, "Bitte geben Sie Ihre Handynummer an: ", true);
    }

    /**
     * Asks the user for his/her city's name
     *
     * @return City's name of the user
     */
    @Override
    public String enterOwnCity () {
        return this.getClient().enterString(3, 50, "Bitte geben Sie Ihre Wohnort ein: ", false);
    }

    /**
     * Asks the user for his/her city's name
     *
     * @return City's name of the user
     */
    @Override
    public String enterOwnComment () {
        return this.getClient().enterString(0, 100, "Kommentar zu Ihrem Eintrag: ", true);
    }

    /**
     * Asks the user for his/her company name
     * 
     * @return User's company name
     */
    @Override
    public String enterOwnCompanyName () {
        return this.getClient().enterString(5, 50, "Bitte geben Sie Ihre Firmenbezeichnung ein: ", true);
    }

    /**
     * Asks user for his/her own country code
     * 
     * @return User's own country code
     */
    @Override
    public String enterOwnCountryCode () {
        return this.getClient().enterString(2, 2, "Bitte geben Sie den zweistelligen Ländercode von Ihrem Land ein: ", false).toUpperCase();
    }

    /**
     * Asks user for his/her own country code
     * 
     * @return User's own country code
     */
    @Override
    public String enterOwnEmailAddress () {
        return this.getClient().enterString(10, 50, "Bitte geben Sie Ihre Email-Adresse ein: ", true);
    }

    /**
     * Asks the user for family name
     * 
     * @return Family name of the user
     */
    @Override
    public String enterOwnFamilyName () {
        return this.getClient().enterString(2, 50, "Bitte geben Sie Ihren Nachnamen ein: ", false);
    }

    /**
     * Asks the user for family name
     * 
     * @return Family name of the user
     */
    @Override
    public String enterOwnFaxNumber () {
        return this.getClient().enterString(5, 30, "Bitte geben Sie Ihre Faxnummer an: ", true);
    }

    /**
     * Asks the user for gender, until a valid has been entered
     * 
     * @return Gender of the user
     */
    @Override
    public char enterOwnGender () {
        return this.getClient().enterChar(new char[] {'M', 'F', 'C'}, "Bitte geben Sie die Anrede ein: (M=Herr, F=Frau, C=Firma): ");
    }

    /**
     * Asks the user for phone number
     * 
     * @return Phone number of the user
     */
    @Override
    public String enterOwnPhoneNumber () {
        return this.getClient().enterString(5, 30, "Bitte geben Sie Ihre Telefonnummer an: ", true);
    }

    /**
     * Asks the user for own street (including number)
     * @return Own street an number
     */
    @Override
    public String enterOwnStreet () {
        return this.getClient().enterString(5, 50, "Bitte geben Sie Ihre Strasse und Hausnummer ein: ", false);
    }

    /**
     * Asks the user for surname
     * @return Surname of the user
     */
    @Override
    public String enterOwnSurname () {
        return this.getClient().enterString(2, 50, "Bitte geben Sie Ihren Vornamen ein: ", false);
    }

    /**
     * Asks the user for own ZIP code
     * 
     * @return ZIP code
     */
    @Override
    public int enterOwnZipCode () {
        return this.getClient().enterInt(0, 99_999, "Bitte geben Sie Ihre Postleitzahl ein: ");
    }

    @Override
    public final int getColumnCount () {
        assert(this.columnNames instanceof List) : "this.columnNames is not initialized";

        return this.columnNames.size();
    }

    /**
     * Getter for column name at given index.
     *
     * @param columnIndex Column index
     * @return Human-readable column name
     */
    @Override
    public String getColumnName (final int columnIndex) {
        assert(this.columnNames instanceof List) : "this.columnNames is not initialized";

        // Get column name at index
        return this.columnNames.get(columnIndex);
    }

    /**
     * Getter for whole contact list
     *
     * @return List of all contacts
     */
    @Override
    public List<Contact> getList () {
        assert(this.contacts instanceof List) : "this.contacts is not initialized";
        return Collections.unmodifiableList(this.contacts);
    }

    /**
     * Checks whether own contact is already added by checking all entries for
     * isOwnContact flag
     *
     * @return Whether own contact is already added
     */
    @Override
    public boolean isOwnContactAdded () {
        // Trace message
        this.getLogger().trace("CALLED!");

        assert(this.contacts instanceof List) : "this.contacts is not initialized";

        // Default is not added
        boolean isAdded = false;
        
        // Now get it back from address book, first get an iterator
        Iterator<Contact> iterator = this.contacts.iterator();
        
        // Check entries
        while (iterator.hasNext()) {
            // Get next entry
            Contact contact = iterator.next();
            
            // Is it valid?
            if (contact instanceof Contact) {
                // Get flag
                isAdded = contact.isOwnContact();
                
                // Is this own contact?
                if (isAdded) {
                    // Then abort loop
                    break;
                }
            }
        }

        // Trace message
        this.getLogger().trace(MessageFormat.format("isAdded={0} : EXIT!", isAdded));

        // Return result
        return isAdded;
    }

    /**
     * Adds given contact to address book and flushes all entries to database
     *
     * @param contact Contact being added
     * @todo Add check for book size
     */
    @Override
    public void registerContact (final Contact contact) {
        // Check if contact is found
        if (this.isContactAlreadyAdded(contact)) {
            // Contact already added
            // @todo Do something here
        } else if ((contact.isOwnContact()) && (this.isOwnContactAdded())) {
            // Own contact already added
            // @todo Do something
        }
        
        // Debug message
        /* NOISY-DEBUG: */ this.getLogger().debug(MessageFormat.format("Adding '{0}' '{1}' at pos '{2}' ...", contact.getSurname(), contact.getFamilyName(), this.size()));
        
        // Add contact to internal list
        this.addContact(contact);
        
        // Flush whole list
        this.flush();
    }

    /**
     * Getter for size
     *
     * @return size of contact "book"
     */
    @Override
    public final int size () {
        assert(this.contacts instanceof List) : "this.contacts is not initialized";
        return this.contacts.size();
    }

    /**
     * Fills the column names array with strings from bundle
     */
    private void fillColumnNamesFromBundle () {
        assert(this.columnNames instanceof List) : "this.columnNames is not initialized";

        // Debug message
        this.getLogger().trace("CALLED!");

        // First get an iterator from key set to iterate over
        Iterator<String> iterator = this.getBundle().keySet().iterator();

        // Then iterate over all
        while (iterator.hasNext()) {
            // Get next element
            String key = iterator.next();

            // Does the key start with ContactManager.columnName ?
            if (key.startsWith("ContactManager.columnName")) {
                // This is the wanted entry.
                this.getLogger().debug(MessageFormat.format("key={0}", key));

                // So add it
                this.columnNames.add(this.getBundle().getString(key));
            }
        }

        // Debug message
        this.getLogger().trace(MessageFormat.format("getColumnCount()={0}: EXIT!", this.getColumnCount()));
    }

    /**
     * Flushes all entries by calling database backend
     */
    private void flush () {
        // Flusgh all
        this.getContactDatabase().flushAllContacts();
    }

    /**
     * A ContactWrapper instance
     *
     * @return the database
     */
    private ContactWrapper getContactDatabase () {
        return this.contactDatabase;
    }

    /**
     * "Getter" for own contact instance or null if not found
     *
     * @return Contact instance or null
     */
    private Contact getOwnContact () {
        assert(this.contacts instanceof List) : "this.contacts is not initialized";

        // Now get it back from address book, first get an iterator
        Iterator<Contact> iterator = this.contacts.iterator();

        // Init instance
        Contact contact = null;

        // Search all contact
        while (iterator.hasNext()) {
            // Get next instance
            Contact next = iterator.next();

            // Is this own contact?
            if (next.isOwnContact()) {
                // Found it
                contact = next;
                break;
                
            }
        }

        // Return instance or null
        return contact;
    }

    /**
     * Checks whether given contact was found in "address book"
     *
     * @param checkContact Contact to be checked
     * @return TRUE if found, FALSE if not found
     */
    private boolean isContactAlreadyAdded (final Contact checkContact) throws NullPointerException {
        assert(this.contacts instanceof List) : "this.contacts is not initialized";

        // Default is not found
        boolean isFound = false;

        // Debug message
        //* NOISY-DEBUG: */ this.getLogger().debug("Checking '" +  this.contacts.length + "' entries...");

        // Now get it back from address book, first get an iterator
        Iterator<Contact> iterator = this.contacts.iterator();

        // Check entries
        while (iterator.hasNext()) {
            // Get next entry
            Contact contact = iterator.next();

            // Debug message
            //* NOISY-DEBUG: */ this.getLogger().debug("contact=" + contact + ",checkContent=" + checkContact);

            // Is it valid?
            if ((contact instanceof Contact) && ((contact.equals(checkContact)))) {
                // Found matching entry
                isFound = true;
                break;
            }
        }

        // Return result
        return isFound;
    }
}