/****************************************************************************
**
** Copyright (C) 2016 Lauri Laanmets (Proekspert AS) <lauri.laanmets@eesti.ee>
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtBluetooth module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

package org.qtproject.qt.android.bluetooth;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.List;

public class QtBluetoothBroadcastReceiver extends BroadcastReceiver
{
    /* Pointer to the Qt object that "owns" the Java object */
    @SuppressWarnings("WeakerAccess")
    long qtObject = 0;
    @SuppressWarnings("WeakerAccess")
    static Context qtContext = null;

    // These are opaque tokens that could be used to match the completed action
    private static final int TURN_BT_ENABLED = 3330;
    private static final int TURN_BT_DISCOVERABLE = 3331;
    private static final int TURN_BT_DISABLED = 3332;

    // The 'Disable' action identifier is hidden in the public APIs so we define it here
    public static final String ACTION_REQUEST_DISABLE =
        "android.bluetooth.adapter.action.REQUEST_DISABLE";

    private static final String TAG = "QtBluetoothBroadcastReceiver";

    public void onReceive(Context context, Intent intent)
    {
        synchronized (qtContext) {
            if (qtObject == 0)
                return;

            jniOnReceive(qtObject, context, intent);
        }
    }

    public void unregisterReceiver()
    {
        synchronized (qtContext) {
            qtObject = 0;
            qtContext.unregisterReceiver(this);
        }
    }

    public native void jniOnReceive(long qtObject, Context context, Intent intent);

    static public void setContext(Context context)
    {
        qtContext = context;
    }

    static public boolean setDisabled()
    {
        if (!(qtContext instanceof android.app.Activity)) {
            Log.w(TAG, "Bluetooth cannot be disabled from a service.");
            return false;
        }
        // The 'disable' is hidden in the public API and as such
        // there are no availability guarantees; may throw an "ActivityNotFoundException"
        Intent intent = new Intent(ACTION_REQUEST_DISABLE);

        try {
            ((Activity)qtContext).startActivityForResult(intent, TURN_BT_DISABLED);
        } catch (Exception ex) {
            Log.w(TAG, "setDisabled() failed to initiate Bluetooth disablement");
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    static public boolean setDiscoverable()
    {
        if (!(qtContext instanceof android.app.Activity)) {
            Log.w(TAG, "Discovery mode cannot be enabled from a service.");
            return false;
        }

        Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
        try {
            ((Activity)qtContext).startActivityForResult(intent, TURN_BT_DISCOVERABLE);
        } catch (Exception ex) {
            Log.w(TAG, "setDiscoverable() failed to initiate Bluetooth discoverability change");
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    static public boolean setEnabled()
    {
        if (!(qtContext instanceof android.app.Activity)) {
            Log.w(TAG, "Bluetooth cannot be enabled from a service.");
            return false;
        }

        Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        try {
            ((Activity)qtContext).startActivityForResult(intent, TURN_BT_ENABLED);
        } catch (Exception ex) {
            Log.w(TAG, "setEnabled() failed to initiate Bluetooth enablement");
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    static public boolean setPairingMode(String address, boolean isPairing)
    {
        BluetoothManager manager =
            (BluetoothManager)qtContext.getSystemService(Context.BLUETOOTH_SERVICE);
        if (manager == null)
            return false;

        BluetoothAdapter adapter = manager.getAdapter();
        if (adapter == null)
            return false;

        // Uses reflection as the removeBond() is not part of public API
        try {
            BluetoothDevice device = adapter.getRemoteDevice(address);
            String methodName = "createBond";
            if (!isPairing)
                methodName = "removeBond";

            Method m = device.getClass()
                    .getMethod(methodName, (Class[]) null);
            m.invoke(device, (Object[]) null);
        } catch (Exception ex) {
            ex.printStackTrace();
            return false;
        }

        return true;
    }

    /*
     * Returns a list of remote devices confirmed to be connected.
     *
     * This list is not complete as it only detects GATT/BtLE related connections.
     * Unfortunately there is no API that provides the complete list.
     *
     */
    static public String[] getConnectedDevices()
    {
        BluetoothManager bluetoothManager =
            (BluetoothManager) qtContext.getSystemService(Context.BLUETOOTH_SERVICE);

        if (bluetoothManager == null) {
            Log.w(TAG, "Failed to retrieve connected devices");
            return new String[0];
        }

        List<BluetoothDevice> gattConnections =
            bluetoothManager.getConnectedDevices(BluetoothProfile.GATT);
        List<BluetoothDevice> gattServerConnections =
             bluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);

        // Process found remote connections but avoid duplications
        HashSet<String> set = new HashSet<String>();
        for (Object gattConnection : gattConnections)
            set.add(gattConnection.toString());

        for (Object gattServerConnection : gattServerConnections)
            set.add(gattServerConnection.toString());

        return set.toArray(new String[set.size()]);
    }
}
