/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.providers.contacts;

import com.android.providers.contacts.ContactsDatabaseHelper.DataColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.PhoneColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.PhoneLookupColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.RawContactsColumns;
import com.android.providers.contacts.ContactsDatabaseHelper.Tables;

import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.DatabaseUtils;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteStatement;
import android.provider.CallLog.Calls;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.Groups;
import android.provider.ContactsContract.RawContacts;
import android.provider.ContactsContract.CommonDataKinds.Email;
import android.provider.ContactsContract.CommonDataKinds.GroupMembership;
import android.provider.ContactsContract.CommonDataKinds.Im;
import android.provider.ContactsContract.CommonDataKinds.Note;
import android.provider.ContactsContract.CommonDataKinds.Organization;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.CommonDataKinds.Photo;
import android.provider.ContactsContract.CommonDataKinds.StructuredName;
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
import android.telephony.PhoneNumberUtils;
import android.text.TextUtils;
import android.util.Log;

import java.io.File;

public class LegacyContactImporter {

    public static final String TAG = "LegacyContactImporter";

    private static final int MAX_ATTEMPTS = 5;
    private static final int DELAY_BETWEEN_ATTEMPTS = 2000;

    public static final String DEFAULT_ACCOUNT_TYPE = "com.google";
    private static final String DATABASE_NAME = "contacts.db";

    private static final int INSERT_BATCH_SIZE = 200;

    /**
     * Estimated increase in database size after import.
     */
    private static final long DATABASE_SIZE_MULTIPLIER = 4;

    /**
     * Estimated minimum database size in megabytes.
     */
    private static final long DATABASE_MIN_SIZE = 5;

    private final Context mContext;
    private final ContactsProvider2 mContactsProvider;
    private ContactsDatabaseHelper mDbHelper;
    private ContentValues mValues = new ContentValues();
    private ContentResolver mResolver;
    private boolean mPhoneticNameAvailable = true;

    private SQLiteDatabase mSourceDb;
    private SQLiteDatabase mTargetDb;

    private NameSplitter mNameSplitter;
    private int mBatchCounter;

    private int mContactCount;

    private long mStructuredNameMimetypeId;
    private long mNoteMimetypeId;
    private long mOrganizationMimetypeId;
    private long mPhoneMimetypeId;
    private long mEmailMimetypeId;
    private long mImMimetypeId;
    private long mPostalMimetypeId;
    private long mPhotoMimetypeId;
    private long mGroupMembershipMimetypeId;

    private long mEstimatedStorageRequirement = DATABASE_MIN_SIZE;

    public LegacyContactImporter(Context context, ContactsProvider2 contactsProvider) {
        mContext = context;
        mContactsProvider = contactsProvider;
        mResolver = mContactsProvider.getContext().getContentResolver();
    }

    public boolean importContacts() throws Exception {
        String path = mContext.getDatabasePath(DATABASE_NAME).getPath();
        File file = new File(path);
        if (!file.exists()) {
            Log.i(TAG, "Legacy contacts database does not exist at " + path);
            return true;
        }

        Log.w(TAG, "Importing contacts from " + path);

        for (int i = 0; i < MAX_ATTEMPTS; i++) {
            try {
                mSourceDb = SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READONLY);
                importContactsFromLegacyDb();
                Log.i(TAG, "Imported legacy contacts: " + mContactCount);
                mContactsProvider.notifyChange();
                return true;

            } catch (SQLiteException e) {
                Log.e(TAG, "Database import exception. Will retry in " + DELAY_BETWEEN_ATTEMPTS
                        + "ms", e);

                // We could get a "database locked" exception here, in which
                // case we should retry
                Thread.sleep(DELAY_BETWEEN_ATTEMPTS);

            } finally {
                if (mSourceDb != null) {
                    mSourceDb.close();
                }
            }
        }

        long oldDatabaseSize = file.length();
        mEstimatedStorageRequirement = oldDatabaseSize * DATABASE_SIZE_MULTIPLIER / 1024 / 1024;
        if (mEstimatedStorageRequirement < DATABASE_MIN_SIZE) {
            mEstimatedStorageRequirement = DATABASE_MIN_SIZE;
        }

        return false;
    }

    public long getEstimatedStorageRequirement() {
        return mEstimatedStorageRequirement;
    }

    private void importContactsFromLegacyDb() {
        int version = mSourceDb.getVersion();

        // Upgrade to version 78 was the latest that wiped out data.  Might as well follow suit
        // and ignore earlier versions.
        if (version < 78) {
            return;
        }

        if (version < 80) {
            mPhoneticNameAvailable = false;
        }

        mDbHelper = (ContactsDatabaseHelper)mContactsProvider.getDatabaseHelper();
        mTargetDb = mDbHelper.getWritableDatabase();

        mStructuredNameMimetypeId = mDbHelper.getMimeTypeId(StructuredName.CONTENT_ITEM_TYPE);
        mNoteMimetypeId = mDbHelper.getMimeTypeId(Note.CONTENT_ITEM_TYPE);
        mOrganizationMimetypeId = mDbHelper.getMimeTypeId(Organization.CONTENT_ITEM_TYPE);
        mPhoneMimetypeId = mDbHelper.getMimeTypeId(Phone.CONTENT_ITEM_TYPE);
        mEmailMimetypeId = mDbHelper.getMimeTypeId(Email.CONTENT_ITEM_TYPE);
        mImMimetypeId = mDbHelper.getMimeTypeId(Im.CONTENT_ITEM_TYPE);
        mPostalMimetypeId = mDbHelper.getMimeTypeId(StructuredPostal.CONTENT_ITEM_TYPE);
        mPhotoMimetypeId = mDbHelper.getMimeTypeId(Photo.CONTENT_ITEM_TYPE);
        mGroupMembershipMimetypeId =
                mDbHelper.getMimeTypeId(GroupMembership.CONTENT_ITEM_TYPE);

        mNameSplitter = mContactsProvider.getNameSplitter();

        mTargetDb.beginTransaction();
        try {
            checkForImportFailureTest();

            /*
             * At this point there should be no data in the contacts provider, but in case
             * some was inserted by mistake, we should remove it. The main reason for this
             * is that we will be preserving original contact IDs and don't want to run into
             * any collisions.
             */
            mContactsProvider.wipeData();

            importGroups();
            importPeople();
            importOrganizations();
            importPhones();
            importContactMethods();
            importPhotos();
            importGroupMemberships();
            updateDisplayNamesAndLookupKeys();

            // Deleted contacts should be inserted after everything else, because
            // the legacy table does not provide an _ID field - the _ID field
            // will be autoincremented
            importDeletedPeople();

            mDbHelper.updateAllVisible();

            mTargetDb.setTransactionSuccessful();
        } finally {
            mTargetDb.endTransaction();
        }

        importCalls();
    }

    /**
     * This is used for simulating an import failure. Insert a row into the "settings"
     * table with key='TEST' and then proceed with the upgrade.  Remove the record
     * after verifying the failure handling.
     */
    private void checkForImportFailureTest() {
        long isTest = DatabaseUtils.longForQuery(mSourceDb,
                "SELECT COUNT(*) FROM settings WHERE key='TEST'", null);
        if (isTest != 0) {
            throw new SQLiteException("Testing import failure.");
        }
    }

    private interface GroupsQuery {
        String TABLE = "groups";

        String[] COLUMNS = {
                "_id", "name", "notes", "should_sync", "system_id", "_sync_account", "_sync_id",
                "_sync_dirty",
        };

        static int ID = 0;
        static int NAME = 1;
        static int NOTES = 2;
        static int SHOULD_SYNC = 3;            // TODO add this feature to Groups
        static int SYSTEM_ID = 4;

        static int _SYNC_ACCOUNT = 5;
        static int _SYNC_ID = 6;
        static int _SYNC_DIRTY = 7;
    }

    private interface GroupsInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.GROUPS + "(" +
                Groups._ID + "," +
                Groups.TITLE + "," +
                Groups.NOTES + "," +
                Groups.SYSTEM_ID + "," +
                Groups.DIRTY + "," +
                Groups.GROUP_VISIBLE + "," +
                Groups.ACCOUNT_NAME + "," +
                Groups.ACCOUNT_TYPE + "," +
                Groups.SOURCE_ID +
        ") VALUES (?,?,?,?,?,?,?,?,?)";

        int ID = 1;
        int TITLE = 2;
        int NOTES = 3;
        int SYSTEM_ID = 4;
        int DIRTY = 5;
        int GROUP_VISIBLE = 6;
        int ACCOUNT_NAME = 7;
        int ACCOUNT_TYPE = 8;
        int SOURCE_ID = 9;
    }

    private void importGroups() {
        SQLiteStatement insert = mTargetDb.compileStatement(GroupsInsert.INSERT_SQL);
        Cursor c = mSourceDb.query(GroupsQuery.TABLE, GroupsQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertGroup(c, insert);
            }
        } finally {
            c.close();
            insert.close();
        }
    }

    private void insertGroup(Cursor c, SQLiteStatement insert) {
        long id = c.getLong(GroupsQuery.ID);

        insert.bindLong(GroupsInsert.ID, id);
        bindString(insert, GroupsInsert.TITLE, c.getString(GroupsQuery.NAME));
        bindString(insert, GroupsInsert.NOTES, c.getString(GroupsQuery.NOTES));
        bindString(insert, GroupsInsert.SYSTEM_ID, c.getString(GroupsQuery.SYSTEM_ID));
        insert.bindLong(GroupsInsert.DIRTY, c.getLong(GroupsQuery._SYNC_DIRTY));
        insert.bindLong(GroupsInsert.GROUP_VISIBLE, 1);

        String account = c.getString(GroupsQuery._SYNC_ACCOUNT);
        if (!TextUtils.isEmpty(account)) {
            bindString(insert, GroupsInsert.ACCOUNT_NAME, account);
            bindString(insert, GroupsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
            bindString(insert, GroupsInsert.SOURCE_ID, c.getString(GroupsQuery._SYNC_ID));
        } else {
            insert.bindNull(GroupsInsert.ACCOUNT_NAME);
            insert.bindNull(GroupsInsert.ACCOUNT_TYPE);
            insert.bindNull(GroupsInsert.SOURCE_ID);
        }
        insert(insert);
    }

    private interface PeopleQuery {
        String TABLE = "people";

        String NAME_SQL =
                "(CASE WHEN (name IS NOT NULL AND name != '') "
                    + "THEN name "
                + "ELSE "
                    + "(CASE WHEN primary_organization is NOT NULL THEN "
                        + "(SELECT company FROM organizations WHERE "
                            + "organizations._id = primary_organization) "
                    + "ELSE "
                        + "(CASE WHEN primary_phone IS NOT NULL THEN "
                            +"(SELECT number FROM phones WHERE phones._id = primary_phone) "
                        + "ELSE "
                            + "(CASE WHEN primary_email IS NOT NULL THEN "
                                + "(SELECT data FROM contact_methods WHERE "
                                    + "contact_methods._id = primary_email) "
                            + "ELSE "
                                + "null "
                            + "END) "
                        + "END) "
                    + "END) "
                + "END) ";


        String[] COLUMNS_WITH_DISPLAY_NAME_WITHOUT_PHONETIC_NAME = {
                "_id", NAME_SQL, "notes", "times_contacted", "last_time_contacted", "starred",
                "primary_phone", "primary_organization", "primary_email", "custom_ringtone",
                "send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
                "_sync_dirty",
        };

        String[] COLUMNS_WITH_DISPLAY_NAME_WITH_PHONETIC_NAME = {
                "_id", NAME_SQL, "notes", "times_contacted", "last_time_contacted", "starred",
                "primary_phone", "primary_organization", "primary_email", "custom_ringtone",
                "send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
                "_sync_dirty", "phonetic_name",
        };

        String[] COLUMNS_WITHOUT_PHONETIC_NAME = {
                "_id", "name", "notes", "times_contacted", "last_time_contacted", "starred",
                "primary_phone", "primary_organization", "primary_email", "custom_ringtone",
                "send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
                "_sync_dirty",
        };

        String[] COLUMNS_WITH_PHONETIC_NAME = {
                "_id", "name", "notes", "times_contacted", "last_time_contacted", "starred",
                "primary_phone", "primary_organization", "primary_email", "custom_ringtone",
                "send_to_voicemail", "_sync_account", "_sync_id", "_sync_time", "_sync_local_id",
                "_sync_dirty", "phonetic_name",
        };

        static int _ID = 0;
        static int NAME = 1;
        static int NOTES = 2;
        static int TIMES_CONTACTED = 3;
        static int LAST_TIME_CONTACTED = 4;
        static int STARRED = 5;
        static int PRIMARY_PHONE = 6;
        static int PRIMARY_ORGANIZATION = 7;
        static int PRIMARY_EMAIL = 8;
        static int CUSTOM_RINGTONE = 9;
        static int SEND_TO_VOICEMAIL = 10;

        static int _SYNC_ACCOUNT = 11;
        static int _SYNC_ID = 12;
        static int _SYNC_TIME = 13;
        static int _SYNC_LOCAL_ID = 14;
        static int _SYNC_DIRTY = 15;

        static int PHONETIC_NAME = 16;
    }


    private interface RawContactsInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.RAW_CONTACTS + "(" +
                RawContacts._ID + "," +
                RawContacts.CONTACT_ID + "," +
                RawContacts.CUSTOM_RINGTONE + "," +
                RawContacts.DIRTY + "," +
                RawContacts.LAST_TIME_CONTACTED + "," +
                RawContacts.SEND_TO_VOICEMAIL + "," +
                RawContacts.STARRED + "," +
                RawContacts.TIMES_CONTACTED + "," +
                RawContacts.SYNC1 + "," +
                RawContacts.SYNC2 + "," +
                RawContacts.ACCOUNT_NAME + "," +
                RawContacts.ACCOUNT_TYPE + "," +
                RawContacts.SOURCE_ID + "," +
                RawContactsColumns.DISPLAY_NAME + "," +
                RawContactsColumns.CONTACT_IN_VISIBLE_GROUP +
         ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";

        int ID = 1;
        int CONTACT_ID = 2;
        int CUSTOM_RINGTONE = 3;
        int DIRTY = 4;
        int LAST_TIME_CONTACTED = 5;
        int SEND_TO_VOICEMAIL = 6;
        int STARRED = 7;
        int TIMES_CONTACTED = 8;
        int SYNC1 = 9;
        int SYNC2 = 10;
        int ACCOUNT_NAME = 11;
        int ACCOUNT_TYPE = 12;
        int SOURCE_ID = 13;
        int DISPLAY_NAME = 14;
        int CONTACT_IN_VISIBLE_GROUP = 15;
    }

    private interface ContactsInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.CONTACTS + "(" +
                Contacts._ID + "," +
                Contacts.CUSTOM_RINGTONE + "," +
                Contacts.LAST_TIME_CONTACTED + "," +
                Contacts.SEND_TO_VOICEMAIL + "," +
                Contacts.STARRED + "," +
                Contacts.TIMES_CONTACTED + "," +
                Contacts.NAME_RAW_CONTACT_ID + "," +
                Contacts.IN_VISIBLE_GROUP +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int ID = 1;
        int CUSTOM_RINGTONE = 2;
        int LAST_TIME_CONTACTED = 3;
        int SEND_TO_VOICEMAIL = 4;
        int STARRED = 5;
        int TIMES_CONTACTED = 6;
        int NAME_RAW_CONTACT_ID = 7;
        int IN_VISIBLE_GROUP = 8;
    }

    private interface StructuredNameInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                StructuredName.DISPLAY_NAME + "," +
                StructuredName.PREFIX + "," +
                StructuredName.GIVEN_NAME + "," +
                StructuredName.MIDDLE_NAME + "," +
                StructuredName.FAMILY_NAME + "," +
                StructuredName.SUFFIX + "," +
                StructuredName.FULL_NAME_STYLE + "," +
                StructuredName.PHONETIC_FAMILY_NAME + "," +
                StructuredName.PHONETIC_MIDDLE_NAME + "," +
                StructuredName.PHONETIC_GIVEN_NAME + "," +
                StructuredName.PHONETIC_NAME_STYLE +
         ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int DISPLAY_NAME = 3;
        int PREFIX = 4;
        int GIVEN_NAME = 5;
        int MIDDLE_NAME = 6;
        int FAMILY_NAME = 7;
        int SUFFIX = 8;
        int FULL_NAME_STYLE = 9;
        int PHONETIC_FAMILY_NAME = 10;
        int PHONETIC_MIDDLE_NAME = 11;
        int PHONETIC_GIVEN_NAME = 12;
        int PHONETIC_NAME_STYLE = 13;
    }

    private interface NoteInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Note.NOTE +
         ") VALUES (?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int NOTE = 3;
    }

    private void importPeople() {
        SQLiteStatement rawContactInsert = mTargetDb.compileStatement(RawContactsInsert.INSERT_SQL);
        SQLiteStatement contactInsert = mTargetDb.compileStatement(ContactsInsert.INSERT_SQL);
        SQLiteStatement structuredNameInsert =
                mTargetDb.compileStatement(StructuredNameInsert.INSERT_SQL);
        SQLiteStatement noteInsert = mTargetDb.compileStatement(NoteInsert.INSERT_SQL);
        try {
            String[] columns = mPhoneticNameAvailable
                    ? PeopleQuery.COLUMNS_WITH_DISPLAY_NAME_WITH_PHONETIC_NAME
                    : PeopleQuery.COLUMNS_WITH_DISPLAY_NAME_WITHOUT_PHONETIC_NAME;
            Cursor c = mSourceDb.query(PeopleQuery.TABLE, columns, "name IS NULL", null, null,
                    null, null);
            try {
                while (c.moveToNext()) {
                    insertRawContact(c, rawContactInsert);
                    insertContact(c, contactInsert);
                    insertNote(c, noteInsert);
                    mContactCount++;
                }
            } finally {
                c.close();
            }

            columns = mPhoneticNameAvailable
                    ? PeopleQuery.COLUMNS_WITH_PHONETIC_NAME
                    : PeopleQuery.COLUMNS_WITHOUT_PHONETIC_NAME;
            c = mSourceDb.query(PeopleQuery.TABLE, columns, "name IS NOT NULL", null, null, null,
                    null);
            try {
                while (c.moveToNext()) {
                    long id = insertRawContact(c, rawContactInsert);
                    insertContact(c, contactInsert);
                    insertStructuredName(c, structuredNameInsert);
                    insertNote(c, noteInsert);
                    mContactCount++;
                }
            } finally {
                c.close();
            }
        } finally {
            rawContactInsert.close();
            contactInsert.close();
            structuredNameInsert.close();
            noteInsert.close();
        }
    }

    private long insertRawContact(Cursor c, SQLiteStatement insert) {
        long id = c.getLong(PeopleQuery._ID);
        insert.bindLong(RawContactsInsert.ID, id);
        insert.bindLong(RawContactsInsert.CONTACT_ID, id);
        bindString(insert, RawContactsInsert.CUSTOM_RINGTONE,
                c.getString(PeopleQuery.CUSTOM_RINGTONE));
        bindString(insert, RawContactsInsert.DIRTY,
                c.getString(PeopleQuery._SYNC_DIRTY));
        insert.bindLong(RawContactsInsert.LAST_TIME_CONTACTED,
                c.getLong(PeopleQuery.LAST_TIME_CONTACTED));
        insert.bindLong(RawContactsInsert.SEND_TO_VOICEMAIL,
                c.getLong(PeopleQuery.SEND_TO_VOICEMAIL));
        insert.bindLong(RawContactsInsert.STARRED,
                c.getLong(PeopleQuery.STARRED));
        insert.bindLong(RawContactsInsert.TIMES_CONTACTED,
                c.getLong(PeopleQuery.TIMES_CONTACTED));
        bindString(insert, RawContactsInsert.SYNC1,
                c.getString(PeopleQuery._SYNC_TIME));
        bindString(insert, RawContactsInsert.SYNC2,
                c.getString(PeopleQuery._SYNC_LOCAL_ID));
        bindString(insert, RawContactsInsert.DISPLAY_NAME,
                c.getString(PeopleQuery.NAME));
        insert.bindLong(RawContactsInsert.CONTACT_IN_VISIBLE_GROUP, 1);

        String account = c.getString(PeopleQuery._SYNC_ACCOUNT);
        if (!TextUtils.isEmpty(account)) {
            bindString(insert, RawContactsInsert.ACCOUNT_NAME, account);
            bindString(insert, RawContactsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
            bindString(insert, RawContactsInsert.SOURCE_ID, c.getString(PeopleQuery._SYNC_ID));
        } else {
            insert.bindNull(RawContactsInsert.ACCOUNT_NAME);
            insert.bindNull(RawContactsInsert.ACCOUNT_TYPE);
            insert.bindNull(RawContactsInsert.SOURCE_ID);
        }
        insert(insert);
        return id;
    }

    private void insertContact(Cursor c, SQLiteStatement insert) {
        long id = c.getLong(PeopleQuery._ID);
        insert.bindLong(ContactsInsert.ID, id);
        bindString(insert, ContactsInsert.CUSTOM_RINGTONE,
                c.getString(PeopleQuery.CUSTOM_RINGTONE));
        insert.bindLong(ContactsInsert.LAST_TIME_CONTACTED,
                c.getLong(PeopleQuery.LAST_TIME_CONTACTED));
        insert.bindLong(ContactsInsert.SEND_TO_VOICEMAIL,
                c.getLong(PeopleQuery.SEND_TO_VOICEMAIL));
        insert.bindLong(ContactsInsert.STARRED,
                c.getLong(PeopleQuery.STARRED));
        insert.bindLong(ContactsInsert.TIMES_CONTACTED,
                c.getLong(PeopleQuery.TIMES_CONTACTED));
        insert.bindLong(ContactsInsert.NAME_RAW_CONTACT_ID, id);
        insert.bindLong(ContactsInsert.IN_VISIBLE_GROUP, 1);

        insert(insert);
    }

    private void insertStructuredName(Cursor c, SQLiteStatement insert) {
        String name = c.getString(PeopleQuery.NAME);
        if (TextUtils.isEmpty(name)) {
            return;
        }

        long id = c.getLong(PeopleQuery._ID);

        insert.bindLong(StructuredNameInsert.RAW_CONTACT_ID, id);
        insert.bindLong(StructuredNameInsert.MIMETYPE_ID, mStructuredNameMimetypeId);
        bindString(insert, StructuredNameInsert.DISPLAY_NAME, name);

        NameSplitter.Name splitName = new NameSplitter.Name();
        mNameSplitter.split(splitName, name);

        bindString(insert, StructuredNameInsert.PREFIX,
                splitName.getPrefix());
        bindString(insert, StructuredNameInsert.GIVEN_NAME,
                splitName.getGivenNames());
        bindString(insert, StructuredNameInsert.MIDDLE_NAME,
                splitName.getMiddleName());
        bindString(insert, StructuredNameInsert.FAMILY_NAME,
                splitName.getFamilyName());
        bindString(insert, StructuredNameInsert.SUFFIX,
                splitName.getSuffix());
        final String joined = mNameSplitter.join(splitName, true);
        bindString(insert, StructuredNameInsert.DISPLAY_NAME, joined);

        if (mPhoneticNameAvailable) {
            String phoneticName = c.getString(PeopleQuery.PHONETIC_NAME);
            if (phoneticName != null) {
                int index = phoneticName.indexOf(' ');
                if (index == -1) {
                    splitName.phoneticFamilyName = phoneticName;
                } else {
                    splitName.phoneticFamilyName = phoneticName.substring(0, index).trim();
                    splitName.phoneticGivenName = phoneticName.substring(index + 1).trim();
                }
            }
        }

        mNameSplitter.guessNameStyle(splitName);

        int fullNameStyle = splitName.getFullNameStyle();
        insert.bindLong(StructuredNameInsert.FULL_NAME_STYLE,
                fullNameStyle);
        bindString(insert, StructuredNameInsert.PHONETIC_FAMILY_NAME,
                splitName.phoneticFamilyName);
        bindString(insert, StructuredNameInsert.PHONETIC_MIDDLE_NAME,
                splitName.phoneticMiddleName);
        bindString(insert, StructuredNameInsert.PHONETIC_GIVEN_NAME,
                splitName.phoneticGivenName);
        insert.bindLong(StructuredNameInsert.PHONETIC_NAME_STYLE,
                splitName.phoneticNameStyle);

        long dataId = insert(insert);

        mContactsProvider.insertNameLookupForStructuredName(id, dataId, name,
                mNameSplitter.getAdjustedFullNameStyle(fullNameStyle));
        if (splitName.phoneticFamilyName != null
                || splitName.phoneticMiddleName != null
                || splitName.phoneticGivenName != null) {
            mContactsProvider.insertNameLookupForPhoneticName(id, dataId,
                    splitName.phoneticFamilyName,
                    splitName.phoneticMiddleName,
                    splitName.phoneticGivenName);
        }
    }

    private void insertNote(Cursor c, SQLiteStatement insert) {
        String notes = c.getString(PeopleQuery.NOTES);

        if (TextUtils.isEmpty(notes)) {
            return;
        }

        long id = c.getLong(PeopleQuery._ID);
        insert.bindLong(NoteInsert.RAW_CONTACT_ID, id);
        insert.bindLong(NoteInsert.MIMETYPE_ID, mNoteMimetypeId);
        bindString(insert, NoteInsert.NOTE, notes);
        insert(insert);
    }

    private interface OrganizationsQuery {
        String TABLE = "organizations";

        String[] COLUMNS = {
                "person", "company", "title", "isprimary", "type", "label",
        };

        static int PERSON = 0;
        static int COMPANY = 1;
        static int TITLE = 2;
        static int ISPRIMARY = 3;
        static int TYPE = 4;
        static int LABEL = 5;
    }

    private interface OrganizationInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Data.IS_PRIMARY + "," +
                Data.IS_SUPER_PRIMARY + "," +
                Organization.COMPANY + "," +
                Organization.TITLE + "," +
                Organization.TYPE + "," +
                Organization.LABEL +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int IS_PRIMARY = 3;
        int IS_SUPER_PRIMARY = 4;
        int COMPANY = 5;
        int TITLE = 6;
        int TYPE = 7;
        int LABEL = 8;
    }

    private void importOrganizations() {
        SQLiteStatement insert = mTargetDb.compileStatement(OrganizationInsert.INSERT_SQL);
        Cursor c = mSourceDb.query(OrganizationsQuery.TABLE, OrganizationsQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertOrganization(c, insert);
            }
        } finally {
            c.close();
            insert.close();
        }
    }

    private void insertOrganization(Cursor c, SQLiteStatement insert) {
        long id = c.getLong(OrganizationsQuery.PERSON);
        insert.bindLong(OrganizationInsert.RAW_CONTACT_ID, id);
        insert.bindLong(OrganizationInsert.MIMETYPE_ID, mOrganizationMimetypeId);
        bindString(insert, OrganizationInsert.IS_PRIMARY, c.getString(OrganizationsQuery.ISPRIMARY));
        bindString(insert, OrganizationInsert.IS_SUPER_PRIMARY,
                c.getString(OrganizationsQuery.ISPRIMARY));
        bindString(insert, OrganizationInsert.COMPANY, c.getString(OrganizationsQuery.COMPANY));
        bindString(insert, OrganizationInsert.TITLE, c.getString(OrganizationsQuery.TITLE));
        bindString(insert, OrganizationInsert.TYPE, c.getString(OrganizationsQuery.TYPE));
        bindString(insert, OrganizationInsert.LABEL, c.getString(OrganizationsQuery.LABEL));
        insert(insert);
    }

    private interface ContactMethodsQuery {
        String TABLE = "contact_methods";

        String[] COLUMNS = {
                "person", "kind", "data", "aux_data", "type", "label", "isprimary",
        };

        static int PERSON = 0;
        static int KIND = 1;
        static int DATA = 2;
        static int AUX_DATA = 3;
        static int TYPE = 4;
        static int LABEL = 5;
        static int ISPRIMARY = 6;
    }

    private interface EmailInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Data.IS_PRIMARY + "," +
                Data.IS_SUPER_PRIMARY + "," +
                Email.DATA + "," +
                Email.TYPE + "," +
                Email.LABEL + "," +
                Data.DATA14 +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int IS_PRIMARY = 3;
        int IS_SUPER_PRIMARY = 4;
        int DATA = 5;
        int TYPE = 6;
        int LABEL = 7;
        int AUX_DATA = 8;
    }

    private interface ImInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Data.IS_PRIMARY + "," +
                Data.IS_SUPER_PRIMARY + "," +
                Im.DATA + "," +
                Im.TYPE + "," +
                Im.LABEL + "," +
                Data.DATA14 +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int IS_PRIMARY = 3;
        int IS_SUPER_PRIMARY = 4;
        int DATA = 5;
        int TYPE = 6;
        int LABEL = 7;
        int AUX_DATA = 8;
    }

    private interface PostalInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Data.IS_PRIMARY + "," +
                Data.IS_SUPER_PRIMARY + "," +
                StructuredPostal.FORMATTED_ADDRESS + "," +
                StructuredPostal.TYPE + "," +
                StructuredPostal.LABEL + "," +
                Data.DATA14 +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int IS_PRIMARY = 3;
        int IS_SUPER_PRIMARY = 4;
        int DATA = 5;
        int TYPE = 6;
        int LABEL = 7;
        int AUX_DATA = 8;
    }

    private void importContactMethods() {
        SQLiteStatement emailInsert = mTargetDb.compileStatement(EmailInsert.INSERT_SQL);
        SQLiteStatement imInsert = mTargetDb.compileStatement(ImInsert.INSERT_SQL);
        SQLiteStatement postalInsert = mTargetDb.compileStatement(PostalInsert.INSERT_SQL);
        Cursor c = mSourceDb.query(ContactMethodsQuery.TABLE, ContactMethodsQuery.COLUMNS, null,
                null, null, null, null);
        try {
            while (c.moveToNext()) {
                int kind = c.getInt(ContactMethodsQuery.KIND);
                switch (kind) {
                    case android.provider.Contacts.KIND_EMAIL:
                        insertEmail(c, emailInsert);
                        break;

                    case android.provider.Contacts.KIND_IM:
                        insertIm(c, imInsert);
                        break;

                    case android.provider.Contacts.KIND_POSTAL:
                        insertPostal(c, postalInsert);
                        break;
                }
            }
        } finally {
            c.close();
            emailInsert.close();
            imInsert.close();
            postalInsert.close();
        }

    }

    private void insertEmail(Cursor c, SQLiteStatement insert) {
        long personId = c.getLong(ContactMethodsQuery.PERSON);
        String email = c.getString(ContactMethodsQuery.DATA);

        insert.bindLong(EmailInsert.RAW_CONTACT_ID, personId);
        insert.bindLong(EmailInsert.MIMETYPE_ID, mEmailMimetypeId);
        bindString(insert, EmailInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, EmailInsert.IS_SUPER_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, EmailInsert.DATA, email);
        bindString(insert, EmailInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
        bindString(insert, EmailInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
        bindString(insert, EmailInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));

        long dataId = insert(insert);
        mContactsProvider.insertNameLookupForEmail(personId, dataId, email);
    }

    private void insertIm(Cursor c, SQLiteStatement insert) {
        long personId = c.getLong(ContactMethodsQuery.PERSON);

        insert.bindLong(ImInsert.RAW_CONTACT_ID, personId);
        insert.bindLong(ImInsert.MIMETYPE_ID, mImMimetypeId);
        bindString(insert, ImInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, ImInsert.IS_SUPER_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, ImInsert.DATA, c.getString(ContactMethodsQuery.DATA));
        bindString(insert, ImInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
        bindString(insert, ImInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
        bindString(insert, ImInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));
        insert(insert);
    }

    private void insertPostal(Cursor c, SQLiteStatement insert) {
        long personId = c.getLong(ContactMethodsQuery.PERSON);

        insert.bindLong(PostalInsert.RAW_CONTACT_ID, personId);
        insert.bindLong(PostalInsert.MIMETYPE_ID, mPostalMimetypeId);
        bindString(insert, PostalInsert.IS_PRIMARY, c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, PostalInsert.IS_SUPER_PRIMARY,
                c.getString(ContactMethodsQuery.ISPRIMARY));
        bindString(insert, PostalInsert.DATA, c.getString(ContactMethodsQuery.DATA));
        bindString(insert, PostalInsert.AUX_DATA, c.getString(ContactMethodsQuery.AUX_DATA));
        bindString(insert, PostalInsert.TYPE, c.getString(ContactMethodsQuery.TYPE));
        bindString(insert, PostalInsert.LABEL, c.getString(ContactMethodsQuery.LABEL));
        insert(insert);
    }

    private interface PhonesQuery {
        String TABLE = "phones";

        String[] COLUMNS = {
                "person", "type", "number", "label", "isprimary",
        };

        static int PERSON = 0;
        static int TYPE = 1;
        static int NUMBER = 2;
        static int LABEL = 3;
        static int ISPRIMARY = 4;
    }

    private interface PhoneInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Data.IS_PRIMARY + "," +
                Data.IS_SUPER_PRIMARY + "," +
                Phone.NUMBER + "," +
                Phone.TYPE + "," +
                Phone.LABEL + "," +
                PhoneColumns.NORMALIZED_NUMBER +
         ") VALUES (?,?,?,?,?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int IS_PRIMARY = 3;
        int IS_SUPER_PRIMARY = 4;
        int NUMBER = 5;
        int TYPE = 6;
        int LABEL = 7;
        int NORMALIZED_NUMBER = 8;
    }

    private interface PhoneLookupInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.PHONE_LOOKUP + "(" +
                PhoneLookupColumns.RAW_CONTACT_ID + "," +
                PhoneLookupColumns.DATA_ID + "," +
                PhoneLookupColumns.NORMALIZED_NUMBER + "," +
                PhoneLookupColumns.MIN_MATCH +
         ") VALUES (?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int DATA_ID = 2;
        int NORMALIZED_NUMBER = 3;
        int MIN_MATCH = 4;
    }

    private interface HasPhoneNumberUpdate {
        String UPDATE_SQL = "UPDATE " + Tables.CONTACTS +
                " SET " + Contacts.HAS_PHONE_NUMBER + "=1 WHERE " + Contacts._ID + "=?";

        int CONTACT_ID = 1;
    }

    private void importPhones() {
        SQLiteStatement phoneInsert = mTargetDb.compileStatement(PhoneInsert.INSERT_SQL);
        SQLiteStatement phoneLookupInsert =
                mTargetDb.compileStatement(PhoneLookupInsert.INSERT_SQL);
        SQLiteStatement hasPhoneUpdate =
                mTargetDb.compileStatement(HasPhoneNumberUpdate.UPDATE_SQL);
        Cursor c = mSourceDb.query(PhonesQuery.TABLE, PhonesQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertPhone(c, phoneInsert, phoneLookupInsert, hasPhoneUpdate);
            }
        } finally {
            c.close();
            phoneInsert.close();
            phoneLookupInsert.close();
            hasPhoneUpdate.close();
        }
    }

    private void insertPhone(Cursor c, SQLiteStatement phoneInsert,
            SQLiteStatement phoneLookupInsert, SQLiteStatement hasPhoneUpdate) {
        long lastUpdatedContact = -1;
        long id = c.getLong(PhonesQuery.PERSON);
        String number = c.getString(PhonesQuery.NUMBER);
        String normalizedNumber = null;
        if (number != null) {
            normalizedNumber = PhoneNumberUtils.getStrippedReversed(number);
        }
        phoneInsert.bindLong(PhoneInsert.RAW_CONTACT_ID, id);
        phoneInsert.bindLong(PhoneInsert.MIMETYPE_ID, mPhoneMimetypeId);
        bindString(phoneInsert, PhoneInsert.IS_PRIMARY, c.getString(PhonesQuery.ISPRIMARY));
        bindString(phoneInsert, PhoneInsert.IS_SUPER_PRIMARY, c.getString(PhonesQuery.ISPRIMARY));
        bindString(phoneInsert, PhoneInsert.NUMBER, number);
        bindString(phoneInsert, PhoneInsert.TYPE, c.getString(PhonesQuery.TYPE));
        bindString(phoneInsert, PhoneInsert.LABEL, c.getString(PhonesQuery.LABEL));
        bindString(phoneInsert, PhoneInsert.NORMALIZED_NUMBER, normalizedNumber);

        long dataId = insert(phoneInsert);
        if (normalizedNumber != null) {
            phoneLookupInsert.bindLong(PhoneLookupInsert.RAW_CONTACT_ID, id);
            phoneLookupInsert.bindLong(PhoneLookupInsert.DATA_ID, dataId);
            phoneLookupInsert.bindString(PhoneLookupInsert.NORMALIZED_NUMBER, normalizedNumber);
            phoneLookupInsert.bindString(PhoneLookupInsert.MIN_MATCH,
                    PhoneNumberUtils.toCallerIDMinMatch(number));
            insert(phoneLookupInsert);

            if (lastUpdatedContact != id) {
                lastUpdatedContact = id;
                hasPhoneUpdate.bindLong(HasPhoneNumberUpdate.CONTACT_ID, id);
                hasPhoneUpdate.execute();
            }
        }
    }

    private interface PhotosQuery {
        String TABLE = "photos";

        String[] COLUMNS = {
                "person", "data", "_sync_id", "_sync_account"
        };

        static int PERSON = 0;
        static int DATA = 1;
        static int _SYNC_ID = 2;
        static int _SYNC_ACCOUNT = 3;
    }

    private interface PhotoInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                Photo.PHOTO + "," +
                Data.SYNC1 +
         ") VALUES (?,?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int PHOTO = 3;
        int SYNC1 = 4;
    }

    private interface PhotoIdUpdate {
        String UPDATE_SQL = "UPDATE " + Tables.CONTACTS +
                " SET " + Contacts.PHOTO_ID + "=? WHERE " + Contacts._ID + "=?";

        int PHOTO_ID = 1;
        int CONTACT_ID = 2;
    }

    private void importPhotos() {
        SQLiteStatement insert = mTargetDb.compileStatement(PhotoInsert.INSERT_SQL);
        SQLiteStatement photoIdUpdate = mTargetDb.compileStatement(PhotoIdUpdate.UPDATE_SQL);
        Cursor c = mSourceDb.query(PhotosQuery.TABLE, PhotosQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertPhoto(c, insert, photoIdUpdate);
            }
        } finally {
            c.close();
            insert.close();
            photoIdUpdate.close();
        }
    }

    private void insertPhoto(Cursor c, SQLiteStatement insert, SQLiteStatement photoIdUpdate) {
        if (c.isNull(PhotosQuery.DATA)) {
            return;
        }

        long personId = c.getLong(PhotosQuery.PERSON);

        insert.bindLong(PhotoInsert.RAW_CONTACT_ID, personId);
        insert.bindLong(PhotoInsert.MIMETYPE_ID, mPhotoMimetypeId);
        insert.bindBlob(PhotoInsert.PHOTO, c.getBlob(PhotosQuery.DATA));

        String account = c.getString(PhotosQuery._SYNC_ACCOUNT);
        if (!TextUtils.isEmpty(account)) {
            bindString(insert, PhotoInsert.SYNC1, c.getString(PhotosQuery._SYNC_ID));
        } else {
            insert.bindNull(PhotoInsert.SYNC1);
        }

        long rowId = insert(insert);
        photoIdUpdate.bindLong(PhotoIdUpdate.PHOTO_ID, rowId);
        photoIdUpdate.bindLong(PhotoIdUpdate.CONTACT_ID, personId);
        photoIdUpdate.execute();
    }

    private interface GroupMembershipQuery {
        String TABLE = "groupmembership";

        String[] COLUMNS = {
                "person", "group_id", "group_sync_account", "group_sync_id"
        };

        static int PERSON_ID = 0;
        static int GROUP_ID = 1;
        static int GROUP_SYNC_ACCOUNT = 2;
        static int GROUP_SYNC_ID = 3;
    }

    private interface GroupMembershipInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.DATA + "(" +
                Data.RAW_CONTACT_ID + "," +
                DataColumns.MIMETYPE_ID + "," +
                GroupMembership.GROUP_ROW_ID +
         ") VALUES (?,?,?)";

        int RAW_CONTACT_ID = 1;
        int MIMETYPE_ID = 2;
        int GROUP_ROW_ID = 3;
    }

    private void importGroupMemberships() {
        SQLiteStatement insert = mTargetDb.compileStatement(GroupMembershipInsert.INSERT_SQL);
        Cursor c = mSourceDb.query(GroupMembershipQuery.TABLE, GroupMembershipQuery.COLUMNS, null,
                null, null, null, null);
        try {
            while (c.moveToNext()) {
                insertGroupMembership(c, insert);
            }
        } finally {
            c.close();
            insert.close();
        }
    }

    private void insertGroupMembership(Cursor c, SQLiteStatement insert) {
        long personId = c.getLong(GroupMembershipQuery.PERSON_ID);

        long groupId = 0;
        if (c.isNull(GroupMembershipQuery.GROUP_ID)) {
            String account = c.getString(GroupMembershipQuery.GROUP_SYNC_ACCOUNT);
            if (!TextUtils.isEmpty(account)) {
                String syncId = c.getString(GroupMembershipQuery.GROUP_SYNC_ID);

                Cursor cursor = mTargetDb.query(Tables.GROUPS,
                        new String[]{Groups._ID}, Groups.SOURCE_ID + "=?", new String[]{syncId},
                        null, null, null);
                try {
                    if (cursor.moveToFirst()) {
                        groupId = cursor.getLong(0);
                    }
                } finally {
                    cursor.close();
                }

                if (groupId == 0) {
                    ContentValues values = new ContentValues();
                    values.put(Groups.ACCOUNT_NAME, account);
                    values.put(Groups.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
                    values.put(Groups.GROUP_VISIBLE, true);
                    values.put(Groups.SOURCE_ID, syncId);
                    groupId = mTargetDb.insert(Tables.GROUPS, null, values);
                }
            }
        } else {
            groupId = c.getLong(GroupMembershipQuery.GROUP_ID);
        }

        insert.bindLong(GroupMembershipInsert.RAW_CONTACT_ID, personId);
        insert.bindLong(GroupMembershipInsert.MIMETYPE_ID, mGroupMembershipMimetypeId);
        insert.bindLong(GroupMembershipInsert.GROUP_ROW_ID, groupId);
        insert(insert);
    }

    private interface CallsQuery {
        String TABLE = "calls";

        String[] COLUMNS = {
                "_id", "number", "date", "duration", "type", "new", "name", "numbertype",
                "numberlabel"
        };

        static int ID = 0;
        static int NUMBER = 1;
        static int DATE = 2;
        static int DURATION = 3;
        static int TYPE = 4;
        static int NEW = 5;
        static int NAME = 6;
        static int NUMBER_TYPE = 7;
        static int NUMBER_LABEL = 8;
    }

    private void importCalls() {
        Cursor c = mSourceDb.query(CallsQuery.TABLE, CallsQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertCall(c);
            }
        } finally {
            c.close();
        }
    }

    private void insertCall(Cursor c) {

        // Cannot use batch operations here, because call log is serviced by a separate provider
        mValues.clear();
        mValues.put(Calls._ID, c.getLong(CallsQuery.ID));
        mValues.put(Calls.NUMBER, c.getString(CallsQuery.NUMBER));
        mValues.put(Calls.DATE, c.getLong(CallsQuery.DATE));
        mValues.put(Calls.DURATION, c.getLong(CallsQuery.DURATION));
        mValues.put(Calls.NEW, c.getLong(CallsQuery.NEW));
        mValues.put(Calls.TYPE, c.getLong(CallsQuery.TYPE));
        mValues.put(Calls.CACHED_NAME, c.getString(CallsQuery.NAME));
        mValues.put(Calls.CACHED_NUMBER_LABEL, c.getString(CallsQuery.NUMBER_LABEL));
        mValues.put(Calls.CACHED_NUMBER_TYPE, c.getString(CallsQuery.NUMBER_TYPE));

        // TODO: confirm that we can use the CallLogProvider at this point, that it is guaranteed
        // to have been registered.
        mResolver.insert(Calls.CONTENT_URI, mValues);
    }

    private void updateDisplayNamesAndLookupKeys() {
        // Compute display names, sort keys, lookup key, etc. for all Raw Cont
        Cursor cursor = mResolver.query(RawContacts.CONTENT_URI,
                new String[] { RawContacts._ID }, null, null, null);
        try {
            while (cursor.moveToNext()) {
                long rawContactId = cursor.getLong(0);
                mContactsProvider.updateRawContactDisplayName(mTargetDb, rawContactId);
                mContactsProvider.updateLookupKeyForRawContact(mTargetDb, rawContactId);
            }
        } finally {
            cursor.close();
        }
    }

    private interface DeletedPeopleQuery {
        String TABLE = "_deleted_people";

        String[] COLUMNS = {
                "_sync_id", "_sync_account"
        };

        static int _SYNC_ID = 0;
        static int _SYNC_ACCOUNT = 1;
    }

    private interface DeletedRawContactInsert {
        String INSERT_SQL = "INSERT INTO " + Tables.RAW_CONTACTS + "(" +
                RawContacts.ACCOUNT_NAME + "," +
                RawContacts.ACCOUNT_TYPE + "," +
                RawContacts.SOURCE_ID + "," +
                RawContacts.DELETED + "," +
                RawContacts.AGGREGATION_MODE +
         ") VALUES (?,?,?,?,?)";


        int ACCOUNT_NAME = 1;
        int ACCOUNT_TYPE = 2;
        int SOURCE_ID = 3;
        int DELETED = 4;
        int AGGREGATION_MODE = 5;
    }

    private void importDeletedPeople() {
        SQLiteStatement insert = mTargetDb.compileStatement(DeletedRawContactInsert.INSERT_SQL);
        Cursor c = mSourceDb.query(DeletedPeopleQuery.TABLE, DeletedPeopleQuery.COLUMNS, null, null,
                null, null, null);
        try {
            while (c.moveToNext()) {
                insertDeletedPerson(c, insert);
            }
        } finally {
            c.close();
            insert.close();
        }
    }

    private void insertDeletedPerson(Cursor c, SQLiteStatement insert) {
        String account = c.getString(DeletedPeopleQuery._SYNC_ACCOUNT);
        if (account == null) {
            return;
        }

        insert.bindString(DeletedRawContactInsert.ACCOUNT_NAME, account);
        insert.bindString(DeletedRawContactInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
        bindString(insert, DeletedRawContactInsert.SOURCE_ID,
                c.getString(DeletedPeopleQuery._SYNC_ID));
        insert.bindLong(DeletedRawContactInsert.DELETED, 1);
        insert.bindLong(DeletedRawContactInsert.AGGREGATION_MODE,
                RawContacts.AGGREGATION_MODE_DISABLED);
        insert(insert);
    }

    private void bindString(SQLiteStatement insert, int index, String string) {
        if (string == null) {
            insert.bindNull(index);
        } else {
            insert.bindString(index, string);
        }
    }

    private long insert(SQLiteStatement insertStatement) {
        long rowId = insertStatement.executeInsert();
        if (rowId == 0) {
            throw new RuntimeException("Insert failed");
        }

        mBatchCounter++;
        if (mBatchCounter >= INSERT_BATCH_SIZE) {
            mTargetDb.setTransactionSuccessful();
            mTargetDb.endTransaction();
            mTargetDb.beginTransaction();
            mBatchCounter = 0;
        }
        return rowId;
    }
}