/*
 * Copyright (C) 2018 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.telephony;

import static android.provider.Telephony.RcsColumns.RcsThreadColumns.RCS_THREAD_URI_PART;
import static android.provider.Telephony.RcsColumns.TRANSACTION_FAILED;

import static com.android.providers.telephony.RcsProviderUtil.buildUriWithRowIdAppended;
import static com.android.providers.telephony.RcsProviderUtil.returnUriAsIsIfSuccessful;

import android.app.AppOpsManager;
import android.content.ContentProvider;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteOpenHelper;
import android.net.Uri;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.util.Log;

import com.android.internal.annotations.VisibleForTesting;

/**
 * Content provider to handle RCS messages. The functionality here is similar to SmsProvider,
 * MmsProvider etc.
 *
 * The provider has constraints around inserting, updating and deleting - the user needs to know
 * whether they are inserting a message that is incoming/outgoing, or the thread they are inserting
 * is a group or p2p etc. This is in order to keep the implementation simple and avoid complex
 * queries.
 *
 * @hide
 */
public class RcsProvider extends ContentProvider {
    static final String TAG = "RcsProvider";
    static final String AUTHORITY = "rcs";
    private static final String CONTENT_AUTHORITY = "content://" + AUTHORITY;

    private static final Uri PARTICIPANT_URI_PREFIX =
            Uri.parse(CONTENT_AUTHORITY + "/participant/");
    private static final Uri P2P_THREAD_URI_PREFIX = Uri.parse(CONTENT_AUTHORITY + "/p2p_thread/");
    private static final Uri FILE_TRANSFER_PREFIX = Uri.parse(
            CONTENT_AUTHORITY + "/file_transfer/");
    static final Uri GROUP_THREAD_URI_PREFIX = Uri.parse(CONTENT_AUTHORITY + "/group_thread/");

    // Rcs table names
    static final String RCS_THREAD_TABLE = "rcs_thread";
    static final String RCS_1_TO_1_THREAD_TABLE = "rcs_1_to_1_thread";
    static final String RCS_GROUP_THREAD_TABLE = "rcs_group_thread";
    static final String UNIFIED_RCS_THREAD_VIEW = "rcs_unified_rcs_thread_view";
    static final String RCS_PARTICIPANT_TABLE = "rcs_participant";
    static final String RCS_PARTICIPANT_THREAD_JUNCTION_TABLE = "rcs_thread_participant";
    static final String RCS_MESSAGE_TABLE = "rcs_message";
    static final String RCS_INCOMING_MESSAGE_TABLE = "rcs_incoming_message";
    static final String RCS_OUTGOING_MESSAGE_TABLE = "rcs_outgoing_message";
    static final String RCS_MESSAGE_DELIVERY_TABLE = "rcs_message_delivery";
    static final String UNIFIED_MESSAGE_VIEW = "rcs_unified_message_view";
    static final String RCS_FILE_TRANSFER_TABLE = "rcs_file_transfer";
    static final String RCS_THREAD_EVENT_TABLE = "rcs_thread_event";
    static final String RCS_PARTICIPANT_EVENT_TABLE = "rcs_participant_event";
    static final String RCS_UNIFIED_EVENT_VIEW = "rcs_unified_event_view";

    private static final UriMatcher URL_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);

    private static final int UNIFIED_RCS_THREAD = 1;
    private static final int UNIFIED_RCS_THREAD_WITH_ID = 2;
    private static final int PARTICIPANT = 3;
    private static final int PARTICIPANT_WITH_ID = 4;
    private static final int PARTICIPANT_ALIAS_CHANGE_EVENT = 5;
    private static final int PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID = 6;
    private static final int P2P_THREAD = 7;
    private static final int P2P_THREAD_WITH_ID = 8;
    private static final int P2P_THREAD_PARTICIPANT = 9;
    private static final int P2P_THREAD_PARTICIPANT_WITH_ID = 10;
    private static final int GROUP_THREAD = 11;
    private static final int GROUP_THREAD_WITH_ID = 12;
    private static final int GROUP_THREAD_PARTICIPANT = 13;
    private static final int GROUP_THREAD_PARTICIPANT_WITH_ID = 14;
    private static final int GROUP_THREAD_PARTICIPANT_JOINED_EVENT = 15;
    private static final int GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID = 16;
    private static final int GROUP_THREAD_PARTICIPANT_LEFT_EVENT = 17;
    private static final int GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID = 18;
    private static final int GROUP_THREAD_NAME_CHANGE_EVENT = 19;
    private static final int GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID = 20;
    private static final int GROUP_THREAD_ICON_CHANGE_EVENT = 21;
    private static final int GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID = 22;
    private static final int UNIFIED_MESSAGE = 23;
    private static final int UNIFIED_MESSAGE_WITH_ID = 24;
    private static final int UNIFIED_MESSAGE_WITH_FILE_TRANSFER = 25;
    private static final int INCOMING_MESSAGE = 26;
    private static final int INCOMING_MESSAGE_WITH_ID = 27;
    private static final int OUTGOING_MESSAGE = 28;
    private static final int OUTGOING_MESSAGE_WITH_ID = 29;
    private static final int OUTGOING_MESSAGE_DELIVERY = 30;
    private static final int OUTGOING_MESSAGE_DELIVERY_WITH_ID = 31;
    private static final int UNIFIED_MESSAGE_ON_THREAD = 32;
    private static final int UNIFIED_MESSAGE_ON_THREAD_WITH_ID = 33;
    private static final int INCOMING_MESSAGE_ON_P2P_THREAD = 34;
    private static final int INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID = 35;
    private static final int OUTGOING_MESSAGE_ON_P2P_THREAD = 36;
    private static final int OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID = 37;
    private static final int INCOMING_MESSAGE_ON_GROUP_THREAD = 38;
    private static final int INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID = 39;
    private static final int OUTGOING_MESSAGE_ON_GROUP_THREAD = 40;
    private static final int OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID = 41;
    private static final int FILE_TRANSFER_WITH_ID = 42;
    private static final int EVENT = 43;
    private static final int CANONICAL_ADDRESS = 44;

    SQLiteOpenHelper mDbOpenHelper;

    @VisibleForTesting
    RcsProviderThreadHelper mThreadHelper;
    @VisibleForTesting
    RcsProviderParticipantHelper mParticipantHelper;
    @VisibleForTesting
    RcsProviderMessageHelper mMessageHelper;
    @VisibleForTesting
    RcsProviderEventHelper mEventHelper;
    @VisibleForTesting
    RcsProviderCanonicalAddressHelper mCanonicalAddressHelper;

    static {
        // example URI: content://rcs/thread
        URL_MATCHER.addURI(AUTHORITY, RCS_THREAD_URI_PART, UNIFIED_RCS_THREAD);

        // example URI: content://rcs/thread/4, where 4 is the thread id.
        URL_MATCHER.addURI(AUTHORITY, "thread/#", UNIFIED_RCS_THREAD_WITH_ID);

        // example URI: content://rcs/participant
        URL_MATCHER.addURI(AUTHORITY, "participant", PARTICIPANT);

        // example URI: content://rcs/participant/12, where 12 is the participant id
        URL_MATCHER.addURI(AUTHORITY, "participant/#", PARTICIPANT_WITH_ID);

        // example URI: content://rcs/participant/12/alias_change_event, where 12 is the participant
        // id.
        URL_MATCHER.addURI(AUTHORITY, "participant/#/alias_change_event",
                PARTICIPANT_ALIAS_CHANGE_EVENT);

        // example URI: content://rcs/participant/12/alias_change_event/4, where 12 is the
        // participant id, and 4 is the event id
        URL_MATCHER.addURI(AUTHORITY, "participant/#/alias_change_event/#",
                PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID);

        // example URI: content://rcs/p2p_thread
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread", P2P_THREAD);

        // example URI: content://rcs/p2p_thread/4, where 4 is the thread id
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#", P2P_THREAD_WITH_ID);

        // example URI: content://rcs/p2p_thread/4/participant, where 4 is the thread id
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/participant", P2P_THREAD_PARTICIPANT);

        // example URI: content://rcs/p2p_thread/9/participant/3", only supports a 1 time insert.
        // 9 is the thread ID, 3 is the participant ID.
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/participant/#", P2P_THREAD_PARTICIPANT_WITH_ID);

        // example URI: content://rcs/group_thread
        URL_MATCHER.addURI(AUTHORITY, "group_thread", GROUP_THREAD);

        // example URI: content://rcs/group_thread/13, where 13 is the _id in rcs_threads table.
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#", GROUP_THREAD_WITH_ID);

        // example URI: content://rcs/group_thread/13/participant_joined_event. Supports
        // queries and inserts
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant_joined_event",
                GROUP_THREAD_PARTICIPANT_JOINED_EVENT);

        // example URI: content://rcs/group_thread/13/participant_joined_event/3. Supports deletes.
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant_joined_event/#",
                GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID);

        // example URI: content://rcs/group_thread/13/participant_left_event. Supports queries
        // and inserts
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant_left_event",
                GROUP_THREAD_PARTICIPANT_LEFT_EVENT);

        // example URI: content://rcs/group_thread/13/participant_left_event/5. Supports deletes
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant_left_event/#",
                GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID);

        // example URI: content://rcs/group_thread/13/name_changed_event. Supports queries and
        // inserts
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/name_changed_event",
                GROUP_THREAD_NAME_CHANGE_EVENT);

        // example URI: content://rcs/group_thread/13/name_changed_event/7. Supports deletes
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/name_changed_event/#",
                GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID);

        // example URI: content://rcs/group_thread/13/icon_changed_event. Supports queries and
        // inserts
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/icon_changed_event",
                GROUP_THREAD_ICON_CHANGE_EVENT);

        // example URI: content://rcs/group_thread/13/icon_changed_event/9. Supports deletes
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/icon_changed_event/#",
                GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID);

        // example URI: content://rcs/group_thread/18/participant
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant",
                GROUP_THREAD_PARTICIPANT);

        // example URI: content://rcs/group_thread/21/participant/4, only supports inserts and
        // deletes
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/participant/#",
                GROUP_THREAD_PARTICIPANT_WITH_ID);

        // example URI: content://rcs/message
        URL_MATCHER.addURI(AUTHORITY, "message", UNIFIED_MESSAGE);

        // example URI: content://rcs/message/4, where 4 is the message id.
        URL_MATCHER.addURI(AUTHORITY, "message/#", UNIFIED_MESSAGE_WITH_ID);

        // example URI: content://rcs/message/4/file_transfer, only supports inserts
        URL_MATCHER.addURI(AUTHORITY, "message/#/file_transfer",
                UNIFIED_MESSAGE_WITH_FILE_TRANSFER);

        // example URI: content://rcs/incoming_message
        URL_MATCHER.addURI(AUTHORITY, "incoming_message", INCOMING_MESSAGE);

        // example URI: content://rcs/incoming_message/45
        URL_MATCHER.addURI(AUTHORITY, "incoming_message/#", INCOMING_MESSAGE_WITH_ID);

        // example URI: content://rcs/outgoing_message
        URL_MATCHER.addURI(AUTHORITY, "outgoing_message", OUTGOING_MESSAGE);

        // example URI: content://rcs/outgoing_message/54
        URL_MATCHER.addURI(AUTHORITY, "outgoing_message/#", OUTGOING_MESSAGE_WITH_ID);

        // example URI: content://rcs/outgoing_message/54/delivery. Only supports queries
        URL_MATCHER.addURI(AUTHORITY, "outgoing_message/#/delivery", OUTGOING_MESSAGE_DELIVERY);

        // example URI: content://rcs/outgoing_message/9/delivery/4. Does not support queries
        URL_MATCHER.addURI(AUTHORITY, "outgoing_message/#/delivery/#",
                OUTGOING_MESSAGE_DELIVERY_WITH_ID);

        // example URI: content://rcs/thread/5/message, only supports querying.
        URL_MATCHER.addURI(AUTHORITY, "thread/#/message", UNIFIED_MESSAGE_ON_THREAD);

        // example URI: content://rcs/thread/5/message/40, only supports querying.
        URL_MATCHER.addURI(AUTHORITY, "thread/#/message/#", UNIFIED_MESSAGE_ON_THREAD_WITH_ID);

        // example URI: content://rcs/p2p_thread/3/incoming_message. Only available for inserting
        // incoming messages onto a 1 to 1 thread.
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/incoming_message",
                INCOMING_MESSAGE_ON_P2P_THREAD);

        // example URI: content://rcs/p2p_thread/11/incoming_message/45. Only supports querying
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/incoming_message/#",
                INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID);

        // example URI: content://rcs/p2p_thread/3/outgoing_message. Only available for inserting
        // outgoing messages onto a 1 to 1 thread.
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/outgoing_message",
                OUTGOING_MESSAGE_ON_P2P_THREAD);

        // example URI: content://rcs/p2p_thread/11/outgoing_message/46. Only supports querying
        URL_MATCHER.addURI(AUTHORITY, "p2p_thread/#/outgoing_message/#",
                OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID);

        // example URI: content://rcs/group_thread/3/incoming_message. Only available for inserting
        // incoming messages onto a group thread.
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/incoming_message",
                INCOMING_MESSAGE_ON_GROUP_THREAD);

        // example URI: content://rcs/group_thread/3/incoming_message/71. Only supports querying
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/incoming_message/#",
                INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID);

        // example URI: content://rcs/group_thread/3/outgoing_message. Only available for inserting
        // outgoing messages onto a group thread.
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/outgoing_message",
                OUTGOING_MESSAGE_ON_GROUP_THREAD);

        // example URI: content://rcs/group_thread/13/outgoing_message/72. Only supports querying
        URL_MATCHER.addURI(AUTHORITY, "group_thread/#/outgoing_message/#",
                OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID);

        // example URI: content://rcs/file_transfer/1. Does not support insertion
        URL_MATCHER.addURI(AUTHORITY, "file_transfer/#", FILE_TRANSFER_WITH_ID);

        // example URI: content://rcs/event
        URL_MATCHER.addURI(AUTHORITY, "event", EVENT);

        URL_MATCHER.addURI(AUTHORITY, "canonical-address", CANONICAL_ADDRESS);
    }

    @Override
    public boolean onCreate() {
        // Use the credential encrypted mmssms.db for RCS messages.
        mDbOpenHelper = MmsSmsDatabaseHelper.getInstanceForCe(getContext());
        mParticipantHelper = new RcsProviderParticipantHelper(mDbOpenHelper);
        mThreadHelper = new RcsProviderThreadHelper(mDbOpenHelper);
        mMessageHelper = new RcsProviderMessageHelper(mDbOpenHelper);
        mEventHelper = new RcsProviderEventHelper(mDbOpenHelper);
        mCanonicalAddressHelper = new RcsProviderCanonicalAddressHelper(mDbOpenHelper);
        return true;
    }

    /**
     * ContentResolver has a weird bug that if both query methods are overridden, it will always
     * pick the bundle one to call, but will still require us to override this one as it is
     * abstract. Work around by putting parameters in a bundle.
     */
    @Override
    public synchronized Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        Bundle bundle = new Bundle();
        bundle.putString(ContentResolver.QUERY_ARG_SQL_SELECTION, selection);
        bundle.putStringArray(ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS, selectionArgs);
        bundle.putString(ContentResolver.QUERY_ARG_SQL_SORT_ORDER, sortOrder);
        return query(uri, projection, bundle, null);
    }

    @Override
    public synchronized Cursor query(Uri uri, String[] projection, Bundle queryArgs,
            CancellationSignal unused) {
        int match = URL_MATCHER.match(uri);

        String selection = null;
        String[] selectionArgs = null;
        String sortOrder = null;

        if (queryArgs != null) {
            selection = queryArgs.getString(ContentResolver.QUERY_ARG_SQL_SELECTION);
            selectionArgs = queryArgs.getStringArray(
                    ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS);
            sortOrder = queryArgs.getString(ContentResolver.QUERY_ARG_SQL_SORT_ORDER);
        }

        switch (match) {
            case UNIFIED_RCS_THREAD:
                return mThreadHelper.queryUnifiedThread(queryArgs);
            case UNIFIED_RCS_THREAD_WITH_ID:
                return mThreadHelper.queryUnifiedThreadUsingId(uri, projection);
            case PARTICIPANT:
                return mParticipantHelper.queryParticipant(queryArgs);
            case PARTICIPANT_WITH_ID:
                return mParticipantHelper.queryParticipantWithId(uri, projection);
            case PARTICIPANT_ALIAS_CHANGE_EVENT:
                Log.e(TAG, "Querying individual event types is not supported, uri: " + uri);
                break;
            case PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Querying participant events with id's is not supported, uri: " + uri);
                break;
            case P2P_THREAD:
                return mThreadHelper.query1to1Thread(projection, selection,
                        selectionArgs, sortOrder);
            case P2P_THREAD_WITH_ID:
                return mThreadHelper.query1To1ThreadUsingId(uri, projection);
            case P2P_THREAD_PARTICIPANT:
                return mParticipantHelper.queryParticipantIn1To1Thread(uri);
            case P2P_THREAD_PARTICIPANT_WITH_ID:
                Log.e(TAG,
                        "Querying participants in 1 to 1 threads via id's is not supported, uri: "
                                + uri);
                break;
            case GROUP_THREAD:
                return mThreadHelper.queryGroupThread(projection, selection,
                        selectionArgs, sortOrder);
            case GROUP_THREAD_WITH_ID:
                return mThreadHelper.queryGroupThreadUsingId(uri, projection);
            case GROUP_THREAD_PARTICIPANT:
                return mParticipantHelper.queryParticipantsInGroupThread(uri);
            case GROUP_THREAD_PARTICIPANT_WITH_ID:
                return mParticipantHelper.queryParticipantInGroupThreadWithId(uri);
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT:
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID:
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT:
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID:
            case GROUP_THREAD_NAME_CHANGE_EVENT:
            case GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID:
            case GROUP_THREAD_ICON_CHANGE_EVENT:
            case GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Querying individual event types is not supported, uri: " + uri);
                break;
            case UNIFIED_MESSAGE:
                return mMessageHelper.queryMessages(queryArgs);
            case UNIFIED_MESSAGE_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithId(uri);
            case UNIFIED_MESSAGE_WITH_FILE_TRANSFER:
                Log.e(TAG,
                        "Querying file transfers through messages is not supported, uri: " + uri);
            case INCOMING_MESSAGE:
                return mMessageHelper.queryIncomingMessageWithSelection(selection, selectionArgs);
            case INCOMING_MESSAGE_WITH_ID:
                return mMessageHelper.queryIncomingMessageWithId(uri);
            case OUTGOING_MESSAGE:
                return mMessageHelper.queryOutgoingMessageWithSelection(selection, selectionArgs);
            case OUTGOING_MESSAGE_WITH_ID:
                return mMessageHelper.queryOutgoingMessageWithId(uri);
            case OUTGOING_MESSAGE_DELIVERY:
                return mMessageHelper.queryOutgoingMessageDeliveries(uri);
            case OUTGOING_MESSAGE_DELIVERY_WITH_ID:
                Log.e(TAG,
                        "Querying deliveries with message and participant ids is not supported, "
                                + "uri: "
                                + uri);
            case UNIFIED_MESSAGE_ON_THREAD:
                return mMessageHelper.queryAllMessagesOnThread(uri, selection, selectionArgs);
            case UNIFIED_MESSAGE_ON_THREAD_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithIdInThread(uri);
            case INCOMING_MESSAGE_ON_P2P_THREAD:
                Log.e(TAG,
                        "Querying incoming messages on P2P thread with selection is not "
                                + "supported, uri: "
                                + uri);
                break;
            case INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithIdInThread(uri);
            case OUTGOING_MESSAGE_ON_P2P_THREAD:
                Log.e(TAG,
                        "Querying outgoing messages on P2P thread with selection is not "
                                + "supported, uri: "
                                + uri);
                break;
            case OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithIdInThread(uri);
            case INCOMING_MESSAGE_ON_GROUP_THREAD:
                Log.e(TAG,
                        "Querying incoming messages on group thread with selection is not "
                                + "supported, uri: "
                                + uri);
                break;
            case INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithIdInThread(uri);
            case OUTGOING_MESSAGE_ON_GROUP_THREAD:
                Log.e(TAG,
                        "Querying outgoing messages on group thread with selection is not "
                                + "supported, uri: "
                                + uri);
                break;
            case OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
                return mMessageHelper.queryUnifiedMessageWithIdInThread(uri);
            case FILE_TRANSFER_WITH_ID:
                return mMessageHelper.queryFileTransfer(uri);
            case EVENT:
                return mEventHelper.queryEvents(queryArgs);
            case CANONICAL_ADDRESS:
                String canonicalAddress = uri.getQueryParameter("address");
                return mCanonicalAddressHelper.getOrCreateCanonicalAddress(canonicalAddress);
            default:
                Log.e(TAG, "Invalid query: " + uri);
        }

        return null;
    }

    @Override
    public String getType(Uri uri) {
        return null;
    }

    @Override
    public synchronized Uri insert(Uri uri, ContentValues values) {
        int match = URL_MATCHER.match(uri);
        long rowId;

        switch (match) {
            case UNIFIED_RCS_THREAD:
            case UNIFIED_RCS_THREAD_WITH_ID:
                Log.e(TAG, "Inserting into unified thread view is not supported, uri: " + uri);
                break;
            case PARTICIPANT:
                return buildUriWithRowIdAppended(PARTICIPANT_URI_PREFIX,
                        mParticipantHelper.insertParticipant(values));
            case PARTICIPANT_WITH_ID:
                Log.e(TAG, "Inserting participant with a specified ID is not supported, uri: "
                        + uri);
                break;
            case PARTICIPANT_ALIAS_CHANGE_EVENT:
                return buildUriWithRowIdAppended(uri,
                        mEventHelper.insertParticipantEvent(uri, values));
            case PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Inserting participant events with id's is not supported, uri: " + uri);
                break;
            case P2P_THREAD:
                return buildUriWithRowIdAppended(P2P_THREAD_URI_PREFIX,
                        mThreadHelper.insert1To1Thread(values));
            case P2P_THREAD_WITH_ID:
                Log.e(TAG, "Inserting a thread with a specified ID is not supported, uri: " + uri);
                break;
            case P2P_THREAD_PARTICIPANT:
                Log.e(TAG,
                        "Inserting a participant into a thread via content values is not "
                                + "supported, uri: "
                                + uri);
                break;
            case P2P_THREAD_PARTICIPANT_WITH_ID:
                Log.e(TAG,
                        "Inserting participant into a thread via URI is not supported, uri: "
                                + uri);
                break;
            case GROUP_THREAD:
                return buildUriWithRowIdAppended(GROUP_THREAD_URI_PREFIX,
                        mThreadHelper.insertGroupThread(values));
            case GROUP_THREAD_WITH_ID:
                Log.e(TAG, "Inserting a thread with a specified ID is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT:
                return buildUriWithRowIdAppended(uri,
                        mEventHelper.insertParticipantJoinedEvent(uri, values));
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID:
                Log.e(TAG, "Inserting thread events with id's is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT:
                return buildUriWithRowIdAppended(uri,
                        mEventHelper.insertParticipantLeftEvent(uri, values));
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID:
                Log.e(TAG, "Inserting thread events with id's is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_NAME_CHANGE_EVENT:
                return buildUriWithRowIdAppended(uri,
                        mEventHelper.insertThreadNameChangeEvent(uri, values));
            case GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Inserting thread events with id's is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_ICON_CHANGE_EVENT:
                return buildUriWithRowIdAppended(uri,
                        mEventHelper.insertThreadIconChangeEvent(uri, values));
            case GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Inserting thread events with id's is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_PARTICIPANT:
                rowId = mParticipantHelper.insertParticipantIntoGroupThread(values);
                if (rowId == TRANSACTION_FAILED) {
                    return null;
                }
                return mParticipantHelper.getParticipantInThreadUri(values, rowId);
            case GROUP_THREAD_PARTICIPANT_WITH_ID:
                return returnUriAsIsIfSuccessful(uri,
                        mParticipantHelper.insertParticipantIntoGroupThreadWithId(uri));
            case UNIFIED_MESSAGE:
            case UNIFIED_MESSAGE_WITH_ID:
                Log.e(TAG, "Inserting into unified message view is not supported, uri: " + uri);
                break;
            case UNIFIED_MESSAGE_WITH_FILE_TRANSFER:
                return buildUriWithRowIdAppended(FILE_TRANSFER_PREFIX,
                        mMessageHelper.insertFileTransferToMessage(uri, values));
            case INCOMING_MESSAGE:
            case INCOMING_MESSAGE_WITH_ID:
            case OUTGOING_MESSAGE:
            case OUTGOING_MESSAGE_WITH_ID:
                Log.e(TAG, "Inserting a message without a thread is not supported, uri: "
                        + uri);
                break;
            case OUTGOING_MESSAGE_DELIVERY:
                Log.e(TAG,
                        "Inserting an outgoing message delivery without a participant is not "
                                + "supported, uri: "
                                + uri);
                break;
            case OUTGOING_MESSAGE_DELIVERY_WITH_ID:
                return returnUriAsIsIfSuccessful(uri,
                        mMessageHelper.insertMessageDelivery(uri, values));
            case UNIFIED_MESSAGE_ON_THREAD:
            case UNIFIED_MESSAGE_ON_THREAD_WITH_ID:
                Log.e(TAG,
                        "Inserting a message on unified thread view is not supported, uri: " + uri);
                break;
            case INCOMING_MESSAGE_ON_P2P_THREAD:
                return mMessageHelper.insertMessageOnThread(uri, values, /* isIncoming= */
                        true, /* is1To1 */ true);
            case OUTGOING_MESSAGE_ON_P2P_THREAD:
                return mMessageHelper.insertMessageOnThread(uri, values, /* isIncoming= */
                        false, /* is1To1 */ true);
            case INCOMING_MESSAGE_ON_GROUP_THREAD:
                return mMessageHelper.insertMessageOnThread(uri, values, /* isIncoming= */
                        true, /* is1To1 */ false);
            case OUTGOING_MESSAGE_ON_GROUP_THREAD:
                return mMessageHelper.insertMessageOnThread(uri, values, /* isIncoming= */
                        false, /* is1To1 */ false);
            case INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
                Log.e(TAG, "Inserting a message with a specific id is not supported, uri: " + uri);
                break;
            case FILE_TRANSFER_WITH_ID:
                Log.e(TAG, "Inserting a file transfer without a message is not supported, uri: "
                        + uri);
                break;
            case EVENT:
                Log.e(TAG,
                        "Inserting event using unified event query is not supported, uri: " + uri);
                break;
            default:
                Log.e(TAG, "Invalid insert: " + uri);
        }

        return null;
    }

    @Override
    public synchronized int delete(Uri uri, String selection, String[] selectionArgs) {
        int match = URL_MATCHER.match(uri);
        int deletedCount = 0;

        switch (match) {
            case UNIFIED_RCS_THREAD:
            case UNIFIED_RCS_THREAD_WITH_ID:
                Log.e(TAG, "Deleting entries from unified view is not allowed: " + uri);
                break;
            case PARTICIPANT:
                Log.e(TAG, "Deleting participant with selection is not allowed: " + uri);
                break;
            case PARTICIPANT_WITH_ID:
                return mParticipantHelper.deleteParticipantWithId(uri);
            case PARTICIPANT_ALIAS_CHANGE_EVENT:
                Log.e(TAG, "Deleting participant events without id is not allowed: " + uri);
                break;
            case PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID:
                return mEventHelper.deleteParticipantEvent(uri);
            case P2P_THREAD:
                return mThreadHelper.delete1To1Thread(selection, selectionArgs);
            case P2P_THREAD_WITH_ID:
                return mThreadHelper.delete1To1ThreadWithId(uri);
            case P2P_THREAD_PARTICIPANT:
                Log.e(TAG, "Removing participant from 1 to 1 thread is not allowed, uri: " + uri);
                break;
            case GROUP_THREAD:
                return mThreadHelper.deleteGroupThread(selection, selectionArgs);
            case GROUP_THREAD_WITH_ID:
                return mThreadHelper.deleteGroupThreadWithId(uri);
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID:
                return mEventHelper.deleteGroupThreadEvent(uri);
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID:
                return mEventHelper.deleteGroupThreadEvent(uri);
            case GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID:
                return mEventHelper.deleteGroupThreadEvent(uri);
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT:
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT:
            case GROUP_THREAD_NAME_CHANGE_EVENT:
            case GROUP_THREAD_ICON_CHANGE_EVENT:
                Log.e(TAG, "Deleting thread events via selection is not allowed, uri: " + uri);
                break;
            case GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID:
                return mEventHelper.deleteGroupThreadEvent(uri);
            case GROUP_THREAD_PARTICIPANT:
                Log.e(TAG,
                        "Deleting a participant from group thread via selection is not allowed, "
                                + "uri: "
                                + uri);
                break;
            case GROUP_THREAD_PARTICIPANT_WITH_ID:
                return mParticipantHelper.deleteParticipantFromGroupThread(uri);
            case UNIFIED_MESSAGE:
                Log.e(TAG,
                        "Deleting message from unified view with selection is not allowed: " + uri);
                break;
            case UNIFIED_MESSAGE_WITH_ID:
                Log.e(TAG, "Deleting message from unified view with id is not allowed: " + uri);
                break;
            case UNIFIED_MESSAGE_WITH_FILE_TRANSFER:
                Log.e(TAG, "Deleting file transfer using message uri is not allowed, uri: " + uri);
                break;
            case INCOMING_MESSAGE:
                return mMessageHelper.deleteIncomingMessageWithSelection(selection, selectionArgs);
            case INCOMING_MESSAGE_WITH_ID:
                return mMessageHelper.deleteIncomingMessageWithId(uri);
            case OUTGOING_MESSAGE:
                return mMessageHelper.deleteOutgoingMessageWithSelection(selection, selectionArgs);
            case OUTGOING_MESSAGE_WITH_ID:
                return mMessageHelper.deleteOutgoingMessageWithId(uri);
            case OUTGOING_MESSAGE_DELIVERY:
            case OUTGOING_MESSAGE_DELIVERY_WITH_ID:
                Log.e(TAG, "Deleting message deliveries is not supported, uri: " + uri);
                break;
            case UNIFIED_MESSAGE_ON_THREAD:
            case UNIFIED_MESSAGE_ON_THREAD_WITH_ID:
            case INCOMING_MESSAGE_ON_P2P_THREAD:
            case INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_P2P_THREAD:
            case OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case INCOMING_MESSAGE_ON_GROUP_THREAD:
            case INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_GROUP_THREAD:
            case OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
                Log.e(TAG, "Deleting messages using thread uris is not supported, uri: " + uri);
                break;
            case FILE_TRANSFER_WITH_ID:
                return mMessageHelper.deleteFileTransfer(uri);
            case EVENT:
                Log.e(TAG, "Deleting events using unified event uri is not supported, uri: " + uri);
                break;
            default:
                Log.e(TAG, "Invalid delete: " + uri);
        }

        return deletedCount;
    }

    @Override
    public synchronized int update(Uri uri, ContentValues values, String selection,
            String[] selectionArgs) {
        int match = URL_MATCHER.match(uri);
        int updatedCount = 0;

        switch (match) {
            case UNIFIED_RCS_THREAD:
            case UNIFIED_RCS_THREAD_WITH_ID:
                Log.e(TAG, "Updating unified thread view is not supported, uri: " + uri);
                break;
            case PARTICIPANT:
                Log.e(TAG, "Updating participants with selection is not supported, uri: " + uri);
                break;
            case PARTICIPANT_WITH_ID:
                return mParticipantHelper.updateParticipantWithId(values, uri);
            case PARTICIPANT_ALIAS_CHANGE_EVENT:
            case PARTICIPANT_ALIAS_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Updating events is not supported, uri: " + uri);
                break;
            case P2P_THREAD:
                return mThreadHelper.update1To1Thread(values, selection, selectionArgs);
            case P2P_THREAD_WITH_ID:
                return mThreadHelper.update1To1ThreadWithId(values, uri);
            case P2P_THREAD_PARTICIPANT:
                Log.e(TAG, "Updating junction table entries is not supported, uri: " + uri);
                break;
            case GROUP_THREAD:
                return mThreadHelper.updateGroupThread(values, selection, selectionArgs);
            case GROUP_THREAD_WITH_ID:
                return mThreadHelper.updateGroupThreadWithId(values, uri);
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT:
            case GROUP_THREAD_PARTICIPANT_JOINED_EVENT_WITH_ID:
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT:
            case GROUP_THREAD_PARTICIPANT_LEFT_EVENT_WITH_ID:
            case GROUP_THREAD_NAME_CHANGE_EVENT:
            case GROUP_THREAD_NAME_CHANGE_EVENT_WITH_ID:
            case GROUP_THREAD_ICON_CHANGE_EVENT:
            case GROUP_THREAD_ICON_CHANGE_EVENT_WITH_ID:
                Log.e(TAG, "Updating thread events is not supported, uri: " + uri);
                break;
            case GROUP_THREAD_PARTICIPANT:
            case GROUP_THREAD_PARTICIPANT_WITH_ID:
                Log.e(TAG, "Updating junction table entries is not supported, uri: " + uri);
                break;
            case UNIFIED_MESSAGE:
            case UNIFIED_MESSAGE_WITH_ID:
                Log.e(TAG, "Updating unified message view is not supported, uri: " + uri);
                break;
            case UNIFIED_MESSAGE_WITH_FILE_TRANSFER:
                Log.e(TAG,
                        "Updating file transfer using unified message uri is not supported, uri: "
                                + uri);
            case INCOMING_MESSAGE:
                Log.e(TAG,
                        "Updating an incoming message via selection is not supported, uri: " + uri);
                break;
            case INCOMING_MESSAGE_WITH_ID:
                return mMessageHelper.updateIncomingMessage(uri, values);
            case OUTGOING_MESSAGE:
                Log.e(TAG,
                        "Updating an outgoing message via selection is not supported, uri: " + uri);
                break;
            case OUTGOING_MESSAGE_WITH_ID:
                return mMessageHelper.updateOutgoingMessage(uri, values);
            case OUTGOING_MESSAGE_DELIVERY:
                Log.e(TAG, "Updating message deliveries using message uris is not supported, uri: "
                        + uri);
                break;
            case OUTGOING_MESSAGE_DELIVERY_WITH_ID:
                return mMessageHelper.updateDelivery(uri, values);
            case UNIFIED_MESSAGE_ON_THREAD:
            case UNIFIED_MESSAGE_ON_THREAD_WITH_ID:
            case INCOMING_MESSAGE_ON_P2P_THREAD:
            case INCOMING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_P2P_THREAD:
            case OUTGOING_MESSAGE_ON_P2P_THREAD_WITH_ID:
            case INCOMING_MESSAGE_ON_GROUP_THREAD:
            case INCOMING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
            case OUTGOING_MESSAGE_ON_GROUP_THREAD:
            case OUTGOING_MESSAGE_ON_GROUP_THREAD_WITH_ID:
                Log.e(TAG, "Updating messages using threads uris is not supported, uri: " + uri);
                break;
            case FILE_TRANSFER_WITH_ID:
                return mMessageHelper.updateFileTransfer(uri, values);
            case EVENT:
                Log.e(TAG, "Updating events is not supported, uri: " + uri);
                break;
            default:
                Log.e(TAG, "Invalid update: " + uri);
        }

        return updatedCount;
    }
}