/*
 * Copyright (C) 2021 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.bluetooth.cts;

import static android.Manifest.permission.BLUETOOTH_CONNECT;
import static android.Manifest.permission.BLUETOOTH_PRIVILEGED;
import static android.bluetooth.BluetoothDevice.ACCESS_ALLOWED;
import static android.bluetooth.BluetoothDevice.ACCESS_REJECTED;
import static android.bluetooth.BluetoothDevice.ACCESS_UNKNOWN;
import static android.bluetooth.BluetoothDevice.TRANSPORT_AUTO;
import static android.bluetooth.BluetoothDevice.TRANSPORT_BREDR;
import static android.bluetooth.BluetoothDevice.TRANSPORT_LE;

import static com.android.compatibility.common.util.SystemUtil.runShellCommand;

import static org.junit.Assert.assertThrows;

import android.app.UiAutomation;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothAudioPolicy;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothStatusCodes;
import android.bluetooth.OobData;
import android.content.AttributionSource;
import android.content.pm.PackageManager;
import android.test.AndroidTestCase;

import androidx.test.InstrumentationRegistry;

import java.io.UnsupportedEncodingException;

public class BluetoothDeviceTest extends AndroidTestCase {

    private boolean mHasBluetooth;
    private boolean mHasCompanionDevice;
    private BluetoothAdapter mAdapter;
    private UiAutomation mUiAutomation;;

    private final String mFakeDeviceAddress = "00:11:22:AA:BB:CC";
    private BluetoothDevice mFakeDevice;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        mHasBluetooth = getContext().getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_BLUETOOTH);

        mHasCompanionDevice = getContext().getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_COMPANION_DEVICE_SETUP);

        if (mHasBluetooth && mHasCompanionDevice) {
            BluetoothManager manager = getContext().getSystemService(BluetoothManager.class);
            mAdapter = manager.getAdapter();
            mUiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
            mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);
            assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
            mFakeDevice = mAdapter.getRemoteDevice(mFakeDeviceAddress);
        }
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
        if (mHasBluetooth && mHasCompanionDevice) {
            mAdapter = null;
            mUiAutomation.dropShellPermissionIdentity();
        }
    }

    public void test_setAlias_getAlias() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        int userId = mContext.getUser().getIdentifier();
        String packageName = mContext.getOpPackageName();

        AttributionSource source = AttributionSource.myAttributionSource();
        assertEquals("android.bluetooth.cts", source.getPackageName());

        // Verifies that when there is no alias, we return the device name
        assertNull(mFakeDevice.getAlias());

        assertThrows(IllegalArgumentException.class, () -> mFakeDevice.setAlias(""));

        String testDeviceAlias = "Test Device Alias";

        // This should throw a SecurityException because there is no CDM association
        assertThrows("BluetoothDevice.setAlias without"
                + " a CDM association or BLUETOOTH_PRIVILEGED permission",
                SecurityException.class, () -> mFakeDevice.setAlias(testDeviceAlias));

        runShellCommand(String.format(
                "cmd companiondevice associate %d %s %s", userId, packageName, mFakeDeviceAddress));
        String output = runShellCommand("dumpsys companiondevice");
        assertTrue("Package name missing from output", output.contains(packageName));
        assertTrue("Device address missing from output",
                output.toLowerCase().contains(mFakeDeviceAddress.toLowerCase()));

        // Takes time to update the CDM cache, so sleep to ensure the association is cached
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }

        /*
         * Device properties don't exist for non-existent BluetoothDevice, so calling setAlias with
         * permissions should return false
         */
        assertEquals(BluetoothStatusCodes.ERROR_DEVICE_NOT_BONDED, mFakeDevice
                .setAlias(testDeviceAlias));
        runShellCommand(String.format("cmd companiondevice disassociate %d %s %s", userId,
                    packageName, mFakeDeviceAddress));

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertNull(mFakeDevice.getAlias());
        assertEquals(BluetoothStatusCodes.ERROR_BLUETOOTH_NOT_ENABLED,
                mFakeDevice.setAlias(testDeviceAlias));
    }

    public void test_getIdentityAddress() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows("No BLUETOOTH_PRIVILEGED permission", SecurityException.class,
                () -> mFakeDevice.getIdentityAddress());
    }

    public void test_getConnectionHandle() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows("No BLUETOOTH_PRIVILEGED permission", SecurityException.class,
                () -> mFakeDevice.getConnectionHandle(TRANSPORT_LE));

        // but it should work after we get the permission
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);
        var handle = mFakeDevice.getConnectionHandle(TRANSPORT_LE);
        assertEquals(handle, BluetoothDevice.ERROR);
    }

    public void test_getAnonymizedAddress() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertEquals("XX:XX:XX:XX:BB:CC", mFakeDevice.getAnonymizedAddress());
    }

    public void test_getBatteryLevel() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertEquals(BluetoothDevice.BATTERY_LEVEL_UNKNOWN, mFakeDevice.getBatteryLevel());

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.getBatteryLevel());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertEquals(BluetoothDevice.BATTERY_LEVEL_BLUETOOTH_OFF, mFakeDevice.getBatteryLevel());
    }

    public void test_isBondingInitiatedLocally() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertFalse(mFakeDevice.isBondingInitiatedLocally());

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.isBondingInitiatedLocally());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.isBondingInitiatedLocally());
    }

    public void test_prepareToEnterProcess() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        mFakeDevice.prepareToEnterProcess(null);
    }

    public void test_setPin() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertFalse(mFakeDevice.setPin((String) null));
        assertFalse(mFakeDevice.setPin("12345678901234567")); // check PIN too big

        assertFalse(mFakeDevice.setPin("123456")); //device is not bonding

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.setPin("123456"));
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.setPin("123456"));
    }

    public void test_connect_disconnect() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice.connect());
        assertThrows(SecurityException.class, () -> mFakeDevice.disconnect());
    }

    public void test_cancelBondProcess() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.cancelBondProcess());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.cancelBondProcess());
    }

    public void test_createBond() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.createBond(TRANSPORT_AUTO));
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.createBond(TRANSPORT_AUTO));
    }

    public void test_createBondOutOfBand() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        OobData data = new OobData.ClassicBuilder(
                new byte[16], new byte[2], new byte[7]).build();

        assertThrows(IllegalArgumentException.class, () -> mFakeDevice.createBondOutOfBand(
                TRANSPORT_AUTO, null, null));

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice
                .createBondOutOfBand(TRANSPORT_AUTO, data, null));
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);
    }

    public void test_getUuids() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertNull(mFakeDevice.getUuids());
        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.getUuids());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertNull(mFakeDevice.getUuids());
    }

    public void test_isEncrypted() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        //Device is not connected
        assertFalse(mFakeDevice.isEncrypted());

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.isEncrypted());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.isEncrypted());
    }

    public void test_removeBond() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        //Device is not bonded
        assertFalse(mFakeDevice.removeBond());

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice.removeBond());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.removeBond());
    }

    public void test_setPinByteArray() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertThrows(NullPointerException.class, () -> mFakeDevice.setPin((byte[]) null));

        // check PIN too big
        assertFalse(mFakeDevice.setPin(convertPinToBytes("12345678901234567")));
        assertFalse(mFakeDevice.setPin(convertPinToBytes("123456"))); // device is not bonding

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setPin(convertPinToBytes("123456")));
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.setPin(convertPinToBytes("123456")));
    }

    public void test_connectGatt() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertThrows(NullPointerException.class, () -> mFakeDevice
                .connectGatt(getContext(), false, null,
                TRANSPORT_AUTO, BluetoothDevice.PHY_LE_1M_MASK));

        assertThrows(NullPointerException.class, () ->
                mFakeDevice.connectGatt(getContext(), false, null,
                TRANSPORT_AUTO, BluetoothDevice.PHY_LE_1M_MASK, null));
    }

    public void test_fetchUuidsWithSdp() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // TRANSPORT_AUTO doesn't need BLUETOOTH_PRIVILEGED permission
        assertTrue(mFakeDevice.fetchUuidsWithSdp(TRANSPORT_AUTO));

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice.fetchUuidsWithSdp(TRANSPORT_BREDR));
        assertThrows(SecurityException.class, () -> mFakeDevice.fetchUuidsWithSdp(TRANSPORT_LE));

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertFalse(mFakeDevice.fetchUuidsWithSdp(TRANSPORT_AUTO));
    }

    public void test_messageAccessPermission() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setMessageAccessPermission(ACCESS_ALLOWED));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setMessageAccessPermission(ACCESS_UNKNOWN));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setMessageAccessPermission(ACCESS_REJECTED));

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        // Should be able to set permissions after adopting the BLUETOOTH_PRIVILEGED permission
        assertTrue(mFakeDevice.setMessageAccessPermission(ACCESS_UNKNOWN));
        assertEquals(ACCESS_UNKNOWN, mFakeDevice.getMessageAccessPermission());
        assertTrue(mFakeDevice.setMessageAccessPermission(ACCESS_ALLOWED));
        assertEquals(ACCESS_ALLOWED, mFakeDevice.getMessageAccessPermission());
        assertTrue(mFakeDevice.setMessageAccessPermission(ACCESS_REJECTED));
        assertEquals(ACCESS_REJECTED, mFakeDevice.getMessageAccessPermission());
    }

    public void test_phonebookAccessPermission() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setPhonebookAccessPermission(ACCESS_ALLOWED));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setPhonebookAccessPermission(ACCESS_UNKNOWN));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setPhonebookAccessPermission(ACCESS_REJECTED));

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        // Should be able to set permissions after adopting the BLUETOOTH_PRIVILEGED permission
        assertTrue(mFakeDevice.setPhonebookAccessPermission(ACCESS_UNKNOWN));
        assertEquals(ACCESS_UNKNOWN, mFakeDevice.getPhonebookAccessPermission());
        assertTrue(mFakeDevice.setPhonebookAccessPermission(ACCESS_ALLOWED));
        assertEquals(ACCESS_ALLOWED, mFakeDevice.getPhonebookAccessPermission());
        assertTrue(mFakeDevice.setPhonebookAccessPermission(ACCESS_REJECTED));
        assertEquals(ACCESS_REJECTED, mFakeDevice.getPhonebookAccessPermission());
    }

    public void test_simAccessPermission() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setSimAccessPermission(ACCESS_ALLOWED));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setSimAccessPermission(ACCESS_UNKNOWN));
        assertThrows(SecurityException.class, () -> mFakeDevice
                .setSimAccessPermission(ACCESS_REJECTED));

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        // Should be able to set permissions after adopting the BLUETOOTH_PRIVILEGED permission
        assertTrue(mFakeDevice.setSimAccessPermission(ACCESS_UNKNOWN));
        assertEquals(ACCESS_UNKNOWN, mFakeDevice.getSimAccessPermission());
        assertTrue(mFakeDevice.setSimAccessPermission(ACCESS_ALLOWED));
        assertEquals(ACCESS_ALLOWED, mFakeDevice.getSimAccessPermission());
        assertTrue(mFakeDevice.setSimAccessPermission(ACCESS_REJECTED));
        assertEquals(ACCESS_REJECTED, mFakeDevice.getSimAccessPermission());
    }

    public void test_getAudioPolicyRemoteSupported() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        assertThrows(SecurityException.class, () -> mFakeDevice.getAudioPolicyRemoteSupported());

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        assertEquals(BluetoothAudioPolicy.FEATURE_UNCONFIGURED_BY_REMOTE,
                mFakeDevice.getAudioPolicyRemoteSupported());
    }

    public void test_setGetAudioPolicy() {
        if (!mHasBluetooth || !mHasCompanionDevice) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }

        BluetoothAudioPolicy demoAudioPolicy = new BluetoothAudioPolicy.Builder().build();

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () -> mFakeDevice.setAudioPolicy(demoAudioPolicy));
        assertThrows(SecurityException.class, () -> mFakeDevice.getAudioPolicy());

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        assertEquals(BluetoothStatusCodes.ERROR_DEVICE_NOT_BONDED,
                mFakeDevice.setAudioPolicy(demoAudioPolicy));
        assertNull(mFakeDevice.getAudioPolicy());

        BluetoothAudioPolicy newPolicy = new BluetoothAudioPolicy.Builder(demoAudioPolicy)
                .setCallEstablishPolicy(BluetoothAudioPolicy.POLICY_ALLOWED)
                .setConnectingTimePolicy(BluetoothAudioPolicy.POLICY_NOT_ALLOWED)
                .setInBandRingtonePolicy(BluetoothAudioPolicy.POLICY_ALLOWED)
                .build();

        assertEquals(BluetoothStatusCodes.ERROR_DEVICE_NOT_BONDED,
                mFakeDevice.setAudioPolicy(newPolicy));
        assertNull(mFakeDevice.getAudioPolicy());

        assertEquals(BluetoothAudioPolicy.POLICY_ALLOWED, newPolicy.getCallEstablishPolicy());
        assertEquals(BluetoothAudioPolicy.POLICY_NOT_ALLOWED, newPolicy.getConnectingTimePolicy());
        assertEquals(BluetoothAudioPolicy.POLICY_ALLOWED, newPolicy.getInBandRingtonePolicy());
    }

    private byte[] convertPinToBytes(String pin) {
        if (pin == null) {
            return null;
        }
        byte[] pinBytes;
        try {
            pinBytes = pin.getBytes("UTF-8");
        } catch (UnsupportedEncodingException uee) {
            return null;
        }
        return pinBytes;
    }
}