/*
 * 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 com.android.car.settings.qc;

import static android.os.UserManager.DISALLOW_BLUETOOTH;
import static android.os.UserManager.DISALLOW_CONFIG_BLUETOOTH;

import static com.android.car.qc.QCItem.QC_ACTION_TOGGLE_STATE;
import static com.android.car.qc.QCItem.QC_TYPE_ACTION_TOGGLE;
import static com.android.car.settings.qc.QCUtils.getActionDisabledDialogIntent;
import static com.android.car.settings.qc.QCUtils.getAvailabilityStatusForZoneFromXml;

import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothClass;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.drawable.Icon;
import android.net.Uri;
import android.os.Bundle;
import android.os.SystemProperties;

import androidx.annotation.DrawableRes;
import androidx.annotation.VisibleForTesting;

import com.android.car.qc.QCActionItem;
import com.android.car.qc.QCItem;
import com.android.car.qc.QCList;
import com.android.car.qc.QCRow;
import com.android.car.settings.R;
import com.android.car.settings.bluetooth.BluetoothUtils;
import com.android.car.settings.common.Logger;
import com.android.car.settings.enterprise.EnterpriseUtils;
import com.android.settingslib.bluetooth.CachedBluetoothDevice;
import com.android.settingslib.bluetooth.HidProfile;
import com.android.settingslib.bluetooth.LocalBluetoothManager;
import com.android.settingslib.bluetooth.LocalBluetoothProfile;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Set;

/**
 * QCItem for showing paired bluetooth devices.
 */
public class PairedBluetoothDevices extends SettingsQCItem {
    @VisibleForTesting
    static final String EXTRA_DEVICE_KEY = "BT_EXTRA_DEVICE_KEY";
    @VisibleForTesting
    static final String EXTRA_BUTTON_TYPE = "BT_EXTRA_BUTTON_TYPE";
    @VisibleForTesting
    static final String BLUETOOTH_BUTTON = "BLUETOOTH_BUTTON";
    @VisibleForTesting
    static final String PHONE_BUTTON = "PHONE_BUTTON";
    @VisibleForTesting
    static final String MEDIA_BUTTON = "MEDIA_BUTTON";
    private static final Logger LOG = new Logger(PairedBluetoothDevices.class);

    private final LocalBluetoothManager mBluetoothManager;
    private final int mDeviceLimit;
    private final boolean mShowDevicesWithoutNames;

    public PairedBluetoothDevices(Context context) {
        super(context);
        setAvailabilityStatusForZone(getAvailabilityStatusForZoneFromXml(context,
                R.xml.bluetooth_settings_fragment, R.string.pk_bluetooth_paired_devices));
        mBluetoothManager = LocalBluetoothManager.getInstance(context, /* onInitCallback= */ null);
        mDeviceLimit = context.getResources().getInteger(
                R.integer.config_qc_bluetooth_device_limit);
        mShowDevicesWithoutNames = SystemProperties.getBoolean(
                BluetoothUtils.BLUETOOTH_SHOW_DEVICES_WITHOUT_NAMES_PROPERTY, false);
    }

    @Override
    QCItem getQCItem() {
        if (!getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)
                || EnterpriseUtils.hasUserRestrictionByDpm(getContext(), DISALLOW_BLUETOOTH)
                || mDeviceLimit == 0 || isHiddenForZone()) {
            return null;
        }

        QCList.Builder listBuilder = new QCList.Builder();

        if (!BluetoothAdapter.getDefaultAdapter().isEnabled()) {
            listBuilder.addRow(new QCRow.Builder()
                    .setIcon(Icon.createWithResource(getContext(),
                            R.drawable.ic_settings_bluetooth_disabled))
                    .setTitle(getContext().getString(R.string.qc_bluetooth_off_devices_info))
                    .build());
            return listBuilder.build();
        }

        Collection<CachedBluetoothDevice> cachedDevices =
                mBluetoothManager.getCachedDeviceManager().getCachedDevicesCopy();

        //TODO(b/198339129): Use BluetoothDeviceFilter.BONDED_DEVICE_FILTER
        Set<BluetoothDevice> bondedDevices = mBluetoothManager.getBluetoothAdapter()
                .getBondedDevices();

        List<CachedBluetoothDevice> filteredDevices = new ArrayList<>();
        for (CachedBluetoothDevice cachedDevice : cachedDevices) {
            if (bondedDevices != null && bondedDevices.contains(cachedDevice.getDevice())) {
                filteredDevices.add(cachedDevice);
            }
        }
        filteredDevices.sort(Comparator.naturalOrder());

        if (filteredDevices.isEmpty()) {
            listBuilder.addRow(new QCRow.Builder()
                    .setIcon(Icon.createWithResource(getContext(),
                            R.drawable.ic_add))
                    .setTitle(getContext().getString(R.string.qc_bluetooth_on_no_devices_info))
                    .build());
            return listBuilder.build();
        }

        int i = 0;
        int deviceLimit = mDeviceLimit >= 0 ? Math.min(mDeviceLimit, filteredDevices.size())
                : filteredDevices.size();
        for (int j = 0; j < deviceLimit; j++) {
            CachedBluetoothDevice cachedDevice = filteredDevices.get(j);
            if (mShowDevicesWithoutNames || cachedDevice.hasHumanReadableName()) {
                listBuilder.addRow(new QCRow.Builder()
                        .setTitle(cachedDevice.getName())
                        .setSubtitle(cachedDevice.getCarConnectionSummary(/* shortSummary= */ true))
                        .setIcon(Icon.createWithResource(getContext(), getIconRes(cachedDevice)))
                        .addEndItem(createBluetoothButton(cachedDevice, i++))
                        .addEndItem(createPhoneButton(cachedDevice, i++))
                        .addEndItem(createMediaButton(cachedDevice, i++))
                        .build()
                );
            }
        }

        return listBuilder.build();
    }

    @Override
    Uri getUri() {
        return SettingsQCRegistry.PAIRED_BLUETOOTH_DEVICES_URI;
    }

    @Override
    void onNotifyChange(Intent intent) {
        String deviceKey = intent.getStringExtra(EXTRA_DEVICE_KEY);
        if (deviceKey == null) {
            return;
        }
        CachedBluetoothDevice device = null;
        Collection<CachedBluetoothDevice> cachedDevices =
                mBluetoothManager.getCachedDeviceManager().getCachedDevicesCopy();
        for (CachedBluetoothDevice cachedDevice : cachedDevices) {
            if (cachedDevice.getAddress().equals(deviceKey)) {
                device = cachedDevice;
                break;
            }
        }
        if (device == null) {
            return;
        }

        String buttonType = intent.getStringExtra(EXTRA_BUTTON_TYPE);
        boolean newState = intent.getBooleanExtra(QC_ACTION_TOGGLE_STATE, true);
        if (BLUETOOTH_BUTTON.equals(buttonType)) {
            if (newState) {
                LocalBluetoothProfile phoneProfile = getProfile(device,
                        BluetoothProfile.HEADSET_CLIENT);
                LocalBluetoothProfile mediaProfile = getProfile(device, BluetoothProfile.A2DP_SINK);
                // If trying to connect and both phone and media are disabled, connecting will
                // always fail. In this case force both profiles on.
                if (phoneProfile != null && mediaProfile != null
                        && !phoneProfile.isEnabled(device.getDevice())
                        && !mediaProfile.isEnabled(device.getDevice())) {
                    phoneProfile.setEnabled(device.getDevice(), true);
                    mediaProfile.setEnabled(device.getDevice(), true);
                }
                device.connect();
            } else if (device.isConnected()) {
                device.disconnect();
            }
        } else if (PHONE_BUTTON.equals(buttonType)) {
            LocalBluetoothProfile profile = getProfile(device, BluetoothProfile.HEADSET_CLIENT);
            if (profile != null) {
                profile.setEnabled(device.getDevice(), newState);
            }
        } else if (MEDIA_BUTTON.equals(buttonType)) {
            LocalBluetoothProfile profile = getProfile(device, BluetoothProfile.A2DP_SINK);
            if (profile != null) {
                profile.setEnabled(device.getDevice(), newState);
            }
        } else {
            LOG.d("Unknown button type: " + buttonType);
        }
    }

    @Override
    Class getBackgroundWorkerClass() {
        return PairedBluetoothDevicesWorker.class;
    }

    @DrawableRes
    private int getIconRes(CachedBluetoothDevice device) {
        BluetoothClass btClass = device.getBtClass();
        if (btClass != null) {
            switch (btClass.getMajorDeviceClass()) {
                case BluetoothClass.Device.Major.COMPUTER:
                    return com.android.internal.R.drawable.ic_bt_laptop;
                case BluetoothClass.Device.Major.PHONE:
                    return com.android.internal.R.drawable.ic_phone;
                case BluetoothClass.Device.Major.PERIPHERAL:
                    return HidProfile.getHidClassDrawable(btClass);
                case BluetoothClass.Device.Major.IMAGING:
                    return com.android.internal.R.drawable.ic_settings_print;
                default:
                    // unrecognized device class; continue
            }
        }

        List<LocalBluetoothProfile> profiles = device.getProfiles();
        for (LocalBluetoothProfile profile : profiles) {
            int resId = profile.getDrawableResource(btClass);
            if (resId != 0) {
                return resId;
            }
        }
        if (btClass != null) {
            if (btClass.doesClassMatch(BluetoothClass.PROFILE_HEADSET)) {
                return com.android.internal.R.drawable.ic_bt_headset_hfp;
            }
            if (btClass.doesClassMatch(BluetoothClass.PROFILE_A2DP)) {
                return com.android.internal.R.drawable.ic_bt_headphones_a2dp;
            }
        }
        return com.android.internal.R.drawable.ic_settings_bluetooth;
    }

    private QCActionItem createBluetoothButton(CachedBluetoothDevice device, int requestCode) {
        return createBluetoothDeviceToggle(device, requestCode, BLUETOOTH_BUTTON,
                Icon.createWithResource(getContext(), R.drawable.ic_qc_bluetooth),
                getContext().getString(
                        R.string.bluetooth_bonded_bluetooth_toggle_content_description),
                true, !device.isBusy(), false, device.isConnected());
    }

    private QCActionItem createPhoneButton(CachedBluetoothDevice device, int requestCode) {
        BluetoothProfileToggleState phoneState = getBluetoothProfileToggleState(device,
                BluetoothProfile.HEADSET_CLIENT);
        int iconRes = phoneState.mIsAvailable ? R.drawable.ic_qc_bluetooth_phone
                : R.drawable.ic_qc_bluetooth_phone_unavailable;
        return createBluetoothDeviceToggle(device, requestCode, PHONE_BUTTON,
                Icon.createWithResource(getContext(), iconRes),
                getContext().getString(R.string.bluetooth_bonded_phone_toggle_content_description),
                phoneState.mIsAvailable, phoneState.mIsEnabled,
                phoneState.mIsClickableWhileDisabled, phoneState.mIsChecked);
    }

    private QCActionItem createMediaButton(CachedBluetoothDevice device, int requestCode) {
        BluetoothProfileToggleState mediaState = getBluetoothProfileToggleState(device,
                BluetoothProfile.A2DP_SINK);
        int iconRes = mediaState.mIsAvailable ? R.drawable.ic_qc_bluetooth_media
                : R.drawable.ic_qc_bluetooth_media_unavailable;
        return createBluetoothDeviceToggle(device, requestCode, MEDIA_BUTTON,
                Icon.createWithResource(getContext(), iconRes),
                getContext().getString(R.string.bluetooth_bonded_media_toggle_content_description),
                mediaState.mIsAvailable, mediaState.mIsEnabled,
                mediaState.mIsClickableWhileDisabled, mediaState.mIsChecked);
    }

    private QCActionItem createBluetoothDeviceToggle(CachedBluetoothDevice device, int requestCode,
            String buttonType, Icon icon, String contentDescription, boolean available,
            boolean enabled,
            boolean clickableWhileDisabled, boolean checked) {
        Bundle extras = new Bundle();
        extras.putString(EXTRA_BUTTON_TYPE, buttonType);
        extras.putString(EXTRA_DEVICE_KEY, device.getAddress());
        PendingIntent action = getBroadcastIntent(extras, requestCode);

        boolean isReadOnlyForZone = isReadOnlyForZone();
        PendingIntent disabledPendingIntent = isReadOnlyForZone
                ? QCUtils.getDisabledToastBroadcastIntent(getContext())
                : getActionDisabledDialogIntent(getContext(), DISALLOW_CONFIG_BLUETOOTH);

        return new QCActionItem.Builder(QC_TYPE_ACTION_TOGGLE)
                .setAvailable(available)
                .setChecked(checked)
                .setEnabled(enabled && isWritableForZone())
                .setClickableWhileDisabled(clickableWhileDisabled | isReadOnlyForZone)
                .setAction(action)
                .setDisabledClickAction(disabledPendingIntent)
                .setIcon(icon)
                .setContentDescription(contentDescription)
                .build();
    }

    private LocalBluetoothProfile getProfile(CachedBluetoothDevice device, int profileId) {
        for (LocalBluetoothProfile profile : device.getProfiles()) {
            if (profile.getProfileId() == profileId) {
                return profile;
            }
        }
        return null;
    }

    private BluetoothProfileToggleState getBluetoothProfileToggleState(CachedBluetoothDevice device,
            int profileId) {
        LocalBluetoothProfile profile = getProfile(device, profileId);
        if (!device.isConnected() || profile == null) {
            return new BluetoothProfileToggleState(false, false, false, false);
        }
        boolean hasUmRestrictions = EnterpriseUtils.hasUserRestrictionByUm(getContext(),
                DISALLOW_CONFIG_BLUETOOTH);
        boolean hasDpmRestrictions = EnterpriseUtils.hasUserRestrictionByDpm(getContext(),
                DISALLOW_CONFIG_BLUETOOTH);
        return new BluetoothProfileToggleState(true, !hasDpmRestrictions && !hasUmRestrictions
                && !device.isBusy(), hasDpmRestrictions, profile.isEnabled(device.getDevice()));
    }

    private static class BluetoothProfileToggleState {
        final boolean mIsAvailable;
        final boolean mIsEnabled;
        final boolean mIsClickableWhileDisabled;
        final boolean mIsChecked;

        BluetoothProfileToggleState(boolean isAvailable, boolean isEnabled,
                boolean isClickableWhileDisabled, boolean isChecked) {
            mIsAvailable = isAvailable;
            mIsEnabled = isEnabled;
            mIsClickableWhileDisabled = isClickableWhileDisabled;
            mIsChecked = isChecked;
        }
    }
}