/*
 * Copyright (C) 2019 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 android.provider;

import static android.provider.BlockedNumberContract.AUTHORITY_URI;
import static android.provider.BlockedNumberContract.EXTRA_ENHANCED_SETTING_KEY;
import static android.provider.BlockedNumberContract.EXTRA_ENHANCED_SETTING_VALUE;
import static android.provider.BlockedNumberContract.RES_BLOCK_STATUS;
import static android.provider.BlockedNumberContract.RES_ENHANCED_SETTING_IS_ENABLED;
import static android.provider.BlockedNumberContract.RES_SHOW_EMERGENCY_CALL_NOTIFICATION;
import static android.provider.BlockedNumberContract.STATUS_NOT_BLOCKED;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_END_BLOCK_SUPPRESSION;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_GET_BLOCK_SUPPRESSION_STATUS;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_GET_ENHANCED_BLOCK_SETTING;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_NOTIFY_EMERGENCY_CONTACT;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_SET_ENHANCED_BLOCK_SETTING;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_SHOULD_SHOW_EMERGENCY_CALL_NOTIFICATION;
import static android.provider.BlockedNumberContract.SystemContract.METHOD_SHOULD_SYSTEM_BLOCK_NUMBER;
import static android.provider.BlockedNumberContract.SystemContract.RES_BLOCKING_SUPPRESSED_UNTIL_TIMESTAMP;
import static android.provider.BlockedNumberContract.SystemContract.RES_IS_BLOCKING_SUPPRESSED;

import android.Manifest;
import android.annotation.FlaggedApi;
import android.annotation.NonNull;
import android.annotation.RequiresPermission;
import android.annotation.SystemApi;
import android.content.Context;
import android.os.Bundle;
import android.telecom.Log;
import android.telecom.TelecomManager;

import com.android.server.telecom.flags.Flags;

/**
 * Constants and methods to interact with the blocked numbers list. This class also serves as
 * a mediator between the BlockedNumber provider and the system: it manages blocking behavior
 * when the user contacts emergency services. Currently, this is only used internally by Telecom.
 *
 * Refer to {@link BlockedNumberContract} for more context.
 * @hide
 */
@SystemApi
@FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
public final class BlockedNumbersManager {
    private static final String LOG_TAG = BlockedNumbersManager.class.getSimpleName();
    private Context mContext;

    /**
     * @hide
     */
    public BlockedNumbersManager(Context context) {
        mContext = context;
    }

    /**
     * A protected broadcast intent action for letting components with
     * {@link android.Manifest.permission#READ_BLOCKED_NUMBERS} know that the block suppression
     * status as returned by {@link #getBlockSuppressionStatus()} has been updated.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ACTION_BLOCK_SUPPRESSION_STATE_CHANGED =
            "android.provider.action.BLOCK_SUPPRESSION_STATE_CHANGED";

    /**
     * Preference key of block numbers not in contacts setting.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_BLOCK_UNREGISTERED =
            "block_numbers_not_in_contacts_setting";

    /**
     * Preference key of block private number calls setting.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_BLOCK_PRIVATE =
            "block_private_number_calls_setting";

    /**
     * Preference key of block payphone calls setting.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_BLOCK_PAYPHONE =
            "block_payphone_calls_setting";

    /**
     * Preference key of block unknown calls setting.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_BLOCK_UNKNOWN =
            "block_unknown_calls_setting";

    /**
     * Preference key for whether should show an emergency call notification.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_SHOW_EMERGENCY_CALL_NOTIFICATION =
            "show_emergency_call_notification";

    /**
     * Preference key of block unavailable calls setting.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final String ENHANCED_SETTING_KEY_BLOCK_UNAVAILABLE =
            "block_unavailable_calls_setting";

    /**
     * Notifies the provider that emergency services were contacted by the user.
     * <p> This results in {@link #shouldSystemBlockNumber} returning {@code false} independent
     * of the contents of the provider for a duration defined by
     * {@link android.telephony.CarrierConfigManager#KEY_DURATION_BLOCKING_DISABLED_AFTER_EMERGENCY_INT}
     * the provider unless {@link #endBlockSuppression()} is called.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public void notifyEmergencyContact() {
        verifyBlockedNumbersPermission();
        try {
            Log.i(LOG_TAG, "notifyEmergencyContact; caller=%s", mContext.getOpPackageName());
            mContext.getContentResolver().call(AUTHORITY_URI, METHOD_NOTIFY_EMERGENCY_CONTACT,
                    null, null);
        } catch (NullPointerException | IllegalArgumentException ex) {
            // The content resolver can throw an NPE or IAE; we don't want to crash Telecom if
            // either of these happen.
            Log.w(null, "notifyEmergencyContact: provider not ready.");
        }
    }

    /**
     * Notifies the provider to disable suppressing blocking. If emergency services were not
     * contacted recently at all, calling this method is a no-op.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public void endBlockSuppression() {
        verifyBlockedNumbersPermission();
        String caller = mContext.getOpPackageName();
        Log.i(LOG_TAG, "endBlockSuppression: caller=%s", caller);
        mContext.getContentResolver().call(AUTHORITY_URI, METHOD_END_BLOCK_SUPPRESSION, null, null);
    }

    /**
     * Returns {@code true} if {@code phoneNumber} is blocked taking
     * {@link #notifyEmergencyContact()} into consideration. If emergency services
     * have not been contacted recently and enhanced call blocking not been enabled, this
     * method is equivalent to {@link BlockedNumberContract#isBlocked(Context, String)}.
     *
     * @param phoneNumber the number to check.
     * @param numberPresentation the presentation code associated with the call.
     * @param isNumberInContacts indicates if the provided number exists as a contact.
     * @return result code indicating if the number should be blocked, and if so why.
     *         Valid values are: {@link BlockedNumberContract#STATUS_NOT_BLOCKED},
     *         {@link BlockedNumberContract#STATUS_BLOCKED_IN_LIST},
     *         {@link BlockedNumberContract#STATUS_BLOCKED_NOT_IN_CONTACTS},
     *         {@link BlockedNumberContract#STATUS_BLOCKED_PAYPHONE},
     *         {@link BlockedNumberContract#STATUS_BLOCKED_RESTRICTED},
     *         {@link BlockedNumberContract#STATUS_BLOCKED_UNKNOWN_NUMBER}.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public int shouldSystemBlockNumber(@NonNull String phoneNumber,
            @TelecomManager.Presentation int numberPresentation, boolean isNumberInContacts) {
        verifyBlockedNumbersPermission();
        try {
            String caller = mContext.getOpPackageName();
            Bundle extras = new Bundle();
            extras.putInt(BlockedNumberContract.EXTRA_CALL_PRESENTATION, numberPresentation);
            extras.putBoolean(BlockedNumberContract.EXTRA_CONTACT_EXIST, isNumberInContacts);
            final Bundle res = mContext.getContentResolver().call(AUTHORITY_URI,
                    METHOD_SHOULD_SYSTEM_BLOCK_NUMBER, phoneNumber, extras);
            int blockResult = res != null ? res.getInt(RES_BLOCK_STATUS, STATUS_NOT_BLOCKED) :
                    BlockedNumberContract.STATUS_NOT_BLOCKED;
            Log.d(LOG_TAG, "shouldSystemBlockNumber: number=%s, caller=%s, result=%s",
                    Log.piiHandle(phoneNumber), caller,
                    BlockedNumberContract.SystemContract.blockStatusToString(blockResult));
            return blockResult;
        } catch (NullPointerException | IllegalArgumentException ex) {
            // The content resolver can throw an NPE or IAE; we don't want to crash Telecom if
            // either of these happen.
            Log.w(null, "shouldSystemBlockNumber: provider not ready.");
            return BlockedNumberContract.STATUS_NOT_BLOCKED;
        }
    }

    /**
     * @return The current status of block suppression.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public @NonNull BlockSuppressionStatus getBlockSuppressionStatus() {
        verifyBlockedNumbersPermission();
        final Bundle res = mContext.getContentResolver().call(
                AUTHORITY_URI, METHOD_GET_BLOCK_SUPPRESSION_STATUS, null, null);
        BlockSuppressionStatus blockSuppressionStatus = new BlockSuppressionStatus(
                res.getBoolean(RES_IS_BLOCKING_SUPPRESSED, false),
                res.getLong(RES_BLOCKING_SUPPRESSED_UNTIL_TIMESTAMP, 0));
        Log.d(LOG_TAG, "getBlockSuppressionStatus: caller=%s, status=%s",
                mContext.getOpPackageName(), blockSuppressionStatus);
        return blockSuppressionStatus;
    }

    /**
     * Check whether should show the emergency call notification.
     *
     * @return {@code true} if should show emergency call notification. {@code false} otherwise.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public boolean shouldShowEmergencyCallNotification() {
        verifyBlockedNumbersPermission();
        try {
            final Bundle res = mContext.getContentResolver().call(AUTHORITY_URI,
                    METHOD_SHOULD_SHOW_EMERGENCY_CALL_NOTIFICATION, null, null);
            return res != null && res.getBoolean(RES_SHOW_EMERGENCY_CALL_NOTIFICATION, false);
        } catch (NullPointerException | IllegalArgumentException ex) {
            // The content resolver can throw an NPE or IAE; we don't want to crash Telecom if
            // either of these happen.
            Log.w(null, "shouldShowEmergencyCallNotification: provider not ready.");
            return false;
        }
    }

    /**
     * Check whether the enhanced block setting is enabled.
     *
     * @param key the key of the setting to check, can be
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNREGISTERED}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_PRIVATE}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_PAYPHONE}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNKNOWN}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNAVAILABLE}
     *        {@link BlockedNumberContract.SystemContract
     *               #ENHANCED_SETTING_KEY_SHOW_EMERGENCY_CALL_NOTIFICATION}
     * @return {@code true} if the setting is enabled. {@code false} otherwise.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public boolean getBlockedNumberSetting(@NonNull String key) {
        verifyBlockedNumbersPermission();
        Bundle extras = new Bundle();
        extras.putString(EXTRA_ENHANCED_SETTING_KEY, key);
        try {
            final Bundle res = mContext.getContentResolver().call(AUTHORITY_URI,
                    METHOD_GET_ENHANCED_BLOCK_SETTING, null, extras);
            return res != null && res.getBoolean(RES_ENHANCED_SETTING_IS_ENABLED, false);
        } catch (NullPointerException | IllegalArgumentException ex) {
            // The content resolver can throw an NPE or IAE; we don't want to crash Telecom if
            // either of these happen.
            Log.w(null, "getEnhancedBlockSetting: provider not ready.");
            return false;
        }
    }

    /**
     * Set the enhanced block setting enabled status.
     *
     * @param key the key of the setting to set, can be
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNREGISTERED}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_PRIVATE}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_PAYPHONE}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNKNOWN}
     *        {@link BlockedNumberContract.SystemContract#ENHANCED_SETTING_KEY_BLOCK_UNAVAILABLE}
     *        {@link BlockedNumberContract.SystemContract
     *               #ENHANCED_SETTING_KEY_SHOW_EMERGENCY_CALL_NOTIFICATION}
     * @param value the enabled statue of the setting to set.
     * @hide
     */
    @SystemApi
    @RequiresPermission(allOf = {
            android.Manifest.permission.READ_BLOCKED_NUMBERS,
            android.Manifest.permission.WRITE_BLOCKED_NUMBERS
    })
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public void setBlockedNumberSetting(@NonNull String key, boolean value) {
        verifyBlockedNumbersPermission();
        Bundle extras = new Bundle();
        extras.putString(EXTRA_ENHANCED_SETTING_KEY, key);
        extras.putBoolean(EXTRA_ENHANCED_SETTING_VALUE, value);
        mContext.getContentResolver().call(AUTHORITY_URI, METHOD_SET_ENHANCED_BLOCK_SETTING,
                null, extras);
    }

    /**
     * Represents the current status of
     * {@link #shouldSystemBlockNumber(String, int, boolean)}. If emergency services
     * have been contacted recently, {@link #mIsSuppressed} is {@code true}, and blocking
     * is disabled until the timestamp {@link #mUntilTimestampMillis}.
     * @hide
     */
    @SystemApi
    @FlaggedApi(Flags.FLAG_TELECOM_MAINLINE_BLOCKED_NUMBERS_MANAGER)
    public static final class BlockSuppressionStatus {
        /**
         * Indicates if block suppression is enabled.
         */
        private boolean mIsSuppressed;

        /**
         * Timestamp in milliseconds from epoch.
         */
        private long mUntilTimestampMillis;

        public BlockSuppressionStatus(boolean isSuppressed, long untilTimestampMillis) {
            this.mIsSuppressed = isSuppressed;
            this.mUntilTimestampMillis = untilTimestampMillis;
        }

        @Override
        public String toString() {
            return "[BlockSuppressionStatus; isSuppressed=" + mIsSuppressed + ", until="
                    + mUntilTimestampMillis + "]";
        }

        /**
         * @return mIsSuppressed Indicates whether or not block suppression is enabled.
         */
        public boolean getIsSuppressed() {
            return mIsSuppressed;
        }

        /**
         * @return mUntilTimestampMillis The timestamp until which block suppression would be
         * enabled for
         */
        public long getUntilTimestampMillis() {
            return mUntilTimestampMillis;
        }
    }

    /**
     * Verifies that the caller holds both the
     * {@link android.Manifest.permission#READ_BLOCKED_NUMBERS} permission and the
     * {@link android.Manifest.permission#WRITE_BLOCKED_NUMBERS} permission.
     *
     * @throws SecurityException if the caller is missing the necessary permissions
     */
    private void verifyBlockedNumbersPermission() {
        mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_BLOCKED_NUMBERS,
                "Caller does not have the android.permission.READ_BLOCKED_NUMBERS permission");
        mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_BLOCKED_NUMBERS,
                "Caller does not have the android.permission.WRITE_BLOCKED_NUMBERS permission");
    }
}