/android/import-contacts

/*

 * ContactsCache.java

 *

 * Copyright (C) 2011 Tim Marston <edam@waxworlds.org>

 *

 * This file is part of the Import Contacts program (hereafter referred

 * to as "this program"). For more information, see

 * http://www.waxworlds.org/edam/software/android/import-contacts

 *

 * 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.waxworlds.edam.importcontacts;

import java.util.HashMap;

import java.util.HashSet;

import org.waxworlds.edam.importcontacts.Importer.AbortImportException;

import android.app.Activity;

import android.database.Cursor;

import android.provider.Contacts;

public class ContactsCache

{

	/**

	 * Information that can be used to identify a contact within the cache

	 */

	static public class CacheIdentifier

	{

		public enum Type {

			NONE, NAME, ORGANISATION, PRIMARY_NUMBER, PRIMARY_EMAIL }

		private Type _type;

		private String _detail;

		protected CacheIdentifier()

		{

			_type = Type.NONE;

		}

		protected CacheIdentifier( Type type, String detail )

		{

			_type = type;

			_detail = detail;

		}

		public Type getType()

		{

			return _type;

		}

		public String getDetail()

		{

			return _detail;

		}

	}

	// mappings of contact names, organisations and primary numbers to ids

	private HashMap< String, Long > _contactsByName;

	private HashMap< String, Long > _contactsByOrg;

	private HashMap< String, Long > _contactsByNumber;

	private HashMap< String, Long > _contactsByEmail;

	// mapping of contact ids to sets of associated data

	private HashMap< Long, HashSet< String > > _contactNumbers;

	private HashMap< Long, HashSet< String > > _contactEmails;

	private HashMap< Long, HashSet< String > > _contactAddresses;

	private HashMap< Long, HashSet< String > > _contactOrganisations;

	public static CacheIdentifier createIdentifier(

		Importer.ContactData contact )

	{

		if( contact.hasName() ) {

			String name = normaliseName( contact.getName() );

			if( name != null )

				return new CacheIdentifier(

					CacheIdentifier.Type.NAME, name );

		}

		if( contact.hasPrimaryOrganisation() ) {

			String organisation = normaliseOrganisation(

				contact.getPrimaryOrganisation() );

			if( organisation != null )

				return new CacheIdentifier(

					CacheIdentifier.Type.ORGANISATION, organisation );

		}

		if( contact.hasPrimaryNumber() ) {

			String number = normalisePhoneNumber( contact.getPrimaryNumber() );

			if( number != null )

			return new CacheIdentifier(

				CacheIdentifier.Type.PRIMARY_NUMBER, number );

		}

		if( contact.hasPrimaryEmail() ) {

			String email = normaliseEmailAddress( contact.getPrimaryEmail() );

			if( email != null )

			return new CacheIdentifier(

				CacheIdentifier.Type.PRIMARY_EMAIL, email );

		}

		return null;

	}

	public boolean canLookup( CacheIdentifier identifier )

	{

		return lookup( identifier ) != null;

	}

	public Long lookup( CacheIdentifier identifier )

	{

		switch( identifier.getType() )

		{

		case NAME:

			return _contactsByName.get( identifier.getDetail() );

		case ORGANISATION:

			return _contactsByOrg.get( identifier.getDetail() );

		case PRIMARY_NUMBER:

			return _contactsByNumber.get( identifier.getDetail() );

		case PRIMARY_EMAIL:

			return _contactsByEmail.get( identifier.getDetail() );

		}

		return null;

	}

	public Long removeLookup( CacheIdentifier identifier )

	{

		switch( identifier.getType() )

		{

		case NAME:

			return _contactsByName.remove( identifier.getDetail() );

		case ORGANISATION:

			return _contactsByOrg.remove( identifier.getDetail() );

		case PRIMARY_NUMBER:

			return _contactsByNumber.remove( identifier.getDetail() );

		case PRIMARY_EMAIL:

			return _contactsByEmail.remove( identifier.getDetail() );

		}

		return null;

	}

	public void addLookup( CacheIdentifier identifier, Long id )

	{

		switch( identifier.getType() )

		{

		case NAME:

			_contactsByName.put( identifier.getDetail(), id );

			break;

		case ORGANISATION:

			_contactsByOrg.put( identifier.getDetail(), id );

			break;

		case PRIMARY_NUMBER:

			_contactsByNumber.put( identifier.getDetail(), id );

			break;

		case PRIMARY_EMAIL:

			_contactsByEmail.put( identifier.getDetail(), id );

			break;

		}

	}

	public void removeAssociatedData( Long id )

	{

		_contactNumbers.remove( id );

		_contactEmails.remove( id );

		_contactAddresses.remove( id );

		_contactOrganisations.remove( id );

	}

	public boolean hasAssociatedNumber( Long id, String number )

	{

		number = normalisePhoneNumber( number );

		if( number == null ) return false;

		HashSet< String > set = _contactNumbers.get( id );

		return set != null && set.contains( number );

	}

	public void addAssociatedNumber( Long id, String number )

	{

		number = normalisePhoneNumber( number );

		if( number == null ) return;

		HashSet< String > set = _contactNumbers.get( id );

		if( set == null ) {

			set = new HashSet< String >();

			_contactNumbers.put( id, set );

		}

		set.add( normalisePhoneNumber( number ) );

	}

	public boolean hasAssociatedEmail( Long id, String email )

	{

		email = normaliseEmailAddress( email );

		if( email == null ) return false;

		HashSet< String > set = _contactEmails.get( id );

		return set != null && set.contains( normaliseEmailAddress( email ) );

	}

	public void addAssociatedEmail( Long id, String email )

	{

		email = normaliseEmailAddress( email );

		if( email == null ) return;

		HashSet< String > set = _contactEmails.get( id );

		if( set == null ) {

			set = new HashSet< String >();

			_contactEmails.put( id, set );

		}

		set.add( normaliseEmailAddress( email ) );

	}

	public boolean hasAssociatedAddress( Long id, String address )

	{

		address = normaliseAddress( address );

		if( address == null ) return false;

		HashSet< String > set = _contactAddresses.get( id );

		return set != null && set.contains( normaliseAddress( address ) );

	}

	public void addAssociatedAddress( Long id, String address )

	{

		address = normaliseAddress( address );

		if( address == null ) return;

		HashSet< String > set = _contactAddresses.get( id );

		if( set == null ) {

			set = new HashSet< String >();

			_contactAddresses.put( id, set );

		}

		set.add( normaliseAddress( address ) );

	}

	public boolean hasAssociatedOrganisation( Long id, String organisation )

	{

		organisation = normaliseOrganisation( organisation );

		if( organisation == null ) return false;

		HashSet< String > set = _contactOrganisations.get( id );

		return set != null && set.contains(

			normaliseOrganisation( organisation ) );

	}

	public void addAssociatedOrganisation( Long id, String organisation )

	{

		organisation = normaliseOrganisation( organisation );

		if( organisation == null ) return;

		HashSet< String > set = _contactOrganisations.get( id );

		if( set == null ) {

			set = new HashSet< String >();

			_contactOrganisations.put( id, set );

		}

		set.add( normaliseOrganisation( organisation ) );

	}

	public void buildCache( Activity activity )

		throws AbortImportException

	{

		Cursor cur;

		// init id lookups

		_contactsByName = new HashMap< String, Long >();

		_contactsByOrg = new HashMap< String, Long >();

		_contactsByNumber = new HashMap< String, Long >();

		_contactsByEmail = new HashMap< String, Long >();

		// init associated data cache

		_contactNumbers = new HashMap< Long, HashSet< String > >();

		_contactEmails = new HashMap< Long, HashSet< String > >();

		_contactAddresses = new HashMap< Long, HashSet< String > >();

		_contactOrganisations = new HashMap< Long, HashSet< String > >();

		// set of contact ids that we have not yet added

		HashSet< Long > unadded = new HashSet< Long >();

		// get all contacts

		cur = activity.managedQuery( Contacts.People.CONTENT_URI,

			new String[] {

				Contacts.People._ID,

				Contacts.People.NAME,

			}, null, null, null );

		while( cur.moveToNext() ) {

			Long id = cur.getLong(

				cur.getColumnIndex( Contacts.People._ID ) );

			String name = normaliseName( cur.getString(

				cur.getColumnIndex( Contacts.People.NAME ) ) );

			if( name != null )

			{

				// if we can, add a lookup for the contact id by name

				if( name.length() > 0 ) {

					addLookup( new CacheIdentifier(

						CacheIdentifier.Type.NAME, name ), id );

					continue;

				}

			}

			// record that a lookup for this contact's id still needs to be

			// added by some other means

			unadded.add( id );

		}

		// get contact organisations, primary ones first

		cur = activity.managedQuery( Contacts.Organizations.CONTENT_URI,

			new String[] {

				Contacts.Phones.PERSON_ID,

				Contacts.Organizations.COMPANY,

			}, null, null, Contacts.Organizations.ISPRIMARY + " DESC" );

		while( cur.moveToNext() ) {

			Long id = cur.getLong( cur.getColumnIndex(

				Contacts.Organizations.PERSON_ID ) );

			String organisation = normaliseOrganisation( cur.getString(

				cur.getColumnIndex( Contacts.Organizations.COMPANY ) ) );

			if( organisation != null )

			{

				// if this is an organisation name for a contact for whom we

				// have not added a lookup, add a lookup for the contact id

				// by organisation

				if( unadded.contains( id ) ) {

					addLookup( new CacheIdentifier(

						CacheIdentifier.Type.ORGANISATION, organisation ), id );

					unadded.remove( id );

				}

				// add associated data

				addAssociatedOrganisation( id, organisation );

			}

		}

		// get all phone numbers, primary ones first

		cur = activity.managedQuery( Contacts.Phones.CONTENT_URI,

			new String[] {

				Contacts.Phones.PERSON_ID,

				Contacts.Phones.NUMBER,

			}, null, null, Contacts.Phones.ISPRIMARY + " DESC" );

		while( cur.moveToNext() ) {

			Long id = cur.getLong(

				cur.getColumnIndex( Contacts.Phones.PERSON_ID ) );

			String number = normalisePhoneNumber( cur.getString(

				cur.getColumnIndex( Contacts.Phones.NUMBER ) ) );

			if( number != null )

			{

				// if this is a number for a contact for whom we have not

				// added a lookup, add a lookup for the contact id by phone

				// number

				if( unadded.contains( id ) ) {

					addLookup( new CacheIdentifier(

						CacheIdentifier.Type.PRIMARY_NUMBER, number ), id );

					unadded.remove( id );

				}

				// add associated data

				addAssociatedNumber( id, number );

			}

		}

		// now get all email addresses, primary ones first, and postal addresses

		cur = activity.managedQuery( Contacts.ContactMethods.CONTENT_URI,

			new String[] {

				Contacts.ContactMethods.PERSON_ID,

				Contacts.ContactMethods.DATA,

				Contacts.ContactMethods.KIND,

			}, Contacts.ContactMethods.KIND + " IN( ?, ? )", new String[] {

				"" + Contacts.KIND_EMAIL,

				"" + Contacts.KIND_POSTAL,

			}, Contacts.ContactMethods.ISPRIMARY + " DESC" );

		while( cur.moveToNext() ) {

			Long id = cur.getLong(

				cur.getColumnIndex( Contacts.ContactMethods.PERSON_ID ) );

			int kind = cur.getInt(

				cur.getColumnIndex( Contacts.ContactMethods.KIND ) );

			if( kind == Contacts.KIND_EMAIL )

			{

				String email = normaliseEmailAddress( cur.getString(

					cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );

				if( email != null )

				{

					// if this is an email address for a contact for whom we

					// have not added a lookup, add a lookup for the contact

					// id by email address

					if( unadded.contains( id ) ) {

						addLookup( new CacheIdentifier(

							CacheIdentifier.Type.PRIMARY_EMAIL, email ), id );

						unadded.remove( id );

					}

					// add associated data

					addAssociatedEmail( id, email );

				}

			}

			else if( kind == Contacts.KIND_POSTAL )

			{

				String address = normaliseAddress( cur.getString(

					cur.getColumnIndex( Contacts.ContactMethods.DATA ) ) );

				if( address != null )

				{

					// add associated data

					addAssociatedAddress( id, address );

				}

			}

		}

	}

	static private String normaliseName( String name )

	{

		if( name == null ) return null;

		name = name.trim();

		return name.length() > 0? name : null;

	}

	static private String normalisePhoneNumber( String number )

	{

		if( number == null ) return null;

		number = number.trim().replaceAll( "[-\\(\\) ]", "" );

		return number.length() > 0? number : null;

	}

	static private String normaliseEmailAddress( String email )

	{

		if( email == null ) return null;

		email = email.trim().toLowerCase();

		return email.length() > 0? email : null;

	}

	static private String normaliseOrganisation( String organisation )

	{

		if( organisation == null ) return null;

		organisation = organisation.trim();

		return organisation.length() > 0? organisation : null;

	}

	static private String normaliseAddress( String address )

	{

		if( address == null ) return null;

		address = address.trim();

		return address.length() > 0? address : null;

	}

}