/*
 * Copyright (C) 2017 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.googlecode.android_scripting.facade.bluetooth;

import android.app.Service;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattServer;
import android.bluetooth.BluetoothGattServerCallback;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.content.Context;
import android.os.Bundle;

import com.googlecode.android_scripting.Log;
import com.googlecode.android_scripting.MainThread;
import com.googlecode.android_scripting.facade.EventFacade;
import com.googlecode.android_scripting.facade.FacadeManager;
import com.googlecode.android_scripting.jsonrpc.RpcReceiver;
import com.googlecode.android_scripting.rpc.Rpc;
import com.googlecode.android_scripting.rpc.RpcParameter;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.Callable;

public class GattServerFacade extends RpcReceiver {
    private final EventFacade mEventFacade;
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothManager mBluetoothManager;
    private final Service mService;
    private final Context mContext;
    private final HashMap<Integer, BluetoothGattCharacteristic> mCharacteristicList;
    private final HashMap<Integer, BluetoothGattDescriptor> mDescriptorList;
    private final HashMap<Integer, BluetoothGattServer> mBluetoothGattServerList;
    private final HashMap<Integer, BtGattServerCallback> mBluetoothGattServerCallbackList;
    private final HashMap<Integer, BluetoothGattService> mGattServiceList;
    private final HashMap<Integer, List<BluetoothGattService>> mBluetoothGattDiscoveredServicesList;
    private final HashMap<Integer, List<BluetoothDevice>> mGattServerDiscoveredDevicesList;
    private static int sCharacteristicCount;
    private static int sDescriptorCount;
    private static int sGattServerCallbackCount;
    private static int sGattServerCount;
    private static int sGattServiceCount;

    public GattServerFacade(FacadeManager manager) {
        super(manager);
        mService = manager.getService();
        mContext = mService.getApplicationContext();
        mBluetoothAdapter = MainThread.run(mService, new Callable<BluetoothAdapter>() {
            @Override
            public BluetoothAdapter call() throws Exception {
                return BluetoothAdapter.getDefaultAdapter();
            }
        });
        mBluetoothManager = (BluetoothManager) mContext.getSystemService(Service.BLUETOOTH_SERVICE);
        mEventFacade = manager.getReceiver(EventFacade.class);
        mCharacteristicList = new HashMap<Integer, BluetoothGattCharacteristic>();
        mDescriptorList = new HashMap<Integer, BluetoothGattDescriptor>();
        mBluetoothGattServerList = new HashMap<Integer, BluetoothGattServer>();
        mBluetoothGattServerCallbackList = new HashMap<Integer, BtGattServerCallback>();
        mGattServiceList = new HashMap<Integer, BluetoothGattService>();
        mBluetoothGattDiscoveredServicesList = new HashMap<Integer, List<BluetoothGattService>>();
        mGattServerDiscoveredDevicesList = new HashMap<Integer, List<BluetoothDevice>>();
    }

    /**
     * Open a new Gatt server.
     *
     * @param index the bluetooth gatt server callback to open on
     * @return the index of the newly opened gatt server
     * @throws Exception
     */
    @Rpc(description = "Open new gatt server")
    public int gattServerOpenGattServer(@RpcParameter(name = "index") Integer index)
            throws Exception {
        if (mBluetoothGattServerCallbackList.get(index) != null) {
            BluetoothGattServer mGattServer =
                    mBluetoothManager.openGattServer(mContext, mBluetoothGattServerCallbackList.get(
                        index));
            sGattServerCount += 1;
            int in = sGattServerCount;
            mBluetoothGattServerList.put(in, mGattServer);
            return in;
        } else {
            throw new Exception("Invalid index input:" + Integer.toString(index));
        }
    }

    /**
     * Add a service to a bluetooth gatt server
     *
     * @param index the bluetooth gatt server to add a service to
     * @param serviceIndex the service to add to the bluetooth gatt server
     * @throws Exception
     */
    @Rpc(description = "Add service to bluetooth gatt server")
    public void gattServerAddService(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "serviceIndex") Integer serviceIndex) throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            if (mGattServiceList.get(serviceIndex) != null) {
                mBluetoothGattServerList.get(index).addService(mGattServiceList.get(serviceIndex));
            } else {
                throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
            }
        } else {
            throw new Exception("Invalid index input:" + Integer.toString(index));
        }
    }

    /**
     * Add a service to a bluetooth gatt server
     *
     * @param index the bluetooth gatt server to add a service to
     * @throws Exception
     */
    @Rpc(description = "Clear services from bluetooth gatt server")
    public void gattServerClearServices(
            @RpcParameter(name = "index") Integer index) throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            mBluetoothGattServerList.get(index).clearServices();
        } else {
            throw new Exception("Invalid index input:" + Integer.toString(index));
        }
    }

    /**
     * Get connected devices of the gatt server
     *
     * @param gattServerIndex the gatt server index
     * @throws Exception
     */
    @Rpc(description = "Return a list of connected gatt devices.")
    public List<BluetoothDevice> gattServerGetConnectedDevices(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex) throws Exception {
        if (mBluetoothGattServerList.get(gattServerIndex) == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices =
                mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);
        mGattServerDiscoveredDevicesList.put(gattServerIndex, connectedDevices);
        return connectedDevices;
    }

    /**
     * Get connected devices of the gatt server
     *
     * @param gattServerIndex the gatt server index
     * @param bluetoothDeviceIndex the remotely connected bluetooth device
     * @param requestId the ID of the request that was received with the callback
     * @param status the status of the request to be sent to the remote devices
     * @param offset value offset for partial read/write response
     * @param value the value of the attribute that was read/written
     * @throws Exception
     */
    @Rpc(description = "Send a response after a write.")
    public void gattServerSendResponse(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
            @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex,
            @RpcParameter(name = "requestId") Integer requestId,
            @RpcParameter(name = "status") Integer status,
            @RpcParameter(name = "offset") Integer offset,
            @RpcParameter(name = "value") byte[] value) throws Exception {

        BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
        if (gattServer == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices =
                mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);
        BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
        gattServer.sendResponse(bluetoothDevice, requestId, status, offset, value);
    }

    /**
     * Notify that characteristic was changed
     *
     * @deprecated Use {@link #gattServerNotifyCharacteristicChangedByInstanceId(
     *  gattServerIndex, bluetoothDeviceIndex, instanceId, confirm)} instead.
     * @param gattServerIndex the gatt server index
     * @param bluetoothDeviceIndex the remotely connected bluetooth device
     * @param characteristicIndex characteristic index
     * @param confirm shall we expect confirmation
     * @throws Exception
     */
    @Deprecated
    @Rpc(description = "Notify that characteristic was changed.")
    public void gattServerNotifyCharacteristicChanged(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
            @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex,
            @RpcParameter(name = "characteristicIndex") Integer characteristicIndex,
            @RpcParameter(name = "confirm") Boolean confirm) throws Exception {

        BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
        if (gattServer == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices =
                mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);
        if (connectedDevices == null) {
            throw new Exception(
                    "Connected device list empty for gattServerIndex:" + Integer.toString(
                        gattServerIndex));
        }
        BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
        if (bluetoothDevice == null) {
            throw new Exception(
                    "Invalid bluetoothDeviceIndex: " + Integer.toString(bluetoothDeviceIndex));
        }

        BluetoothGattCharacteristic bluetoothCharacteristic = mCharacteristicList.get(
                characteristicIndex);
        if (bluetoothCharacteristic == null) {
            throw new Exception(
                    "Invalid characteristicIndex: " + Integer.toString(characteristicIndex));
        }

        gattServer.notifyCharacteristicChanged(bluetoothDevice, bluetoothCharacteristic, confirm);
    }

    /**
     * Notify that characteristic was changed
     *
     * @param gattServerIndex the gatt server index
     * @param bluetoothDeviceIndex the remotely connected bluetooth device
     * @param characteristicIndex characteristic index
     * @param confirm shall we expect confirmation
     * @throws Exception
     */
    @Rpc(description = "Notify that characteristic was changed by Instance Id.")
    public void gattServerNotifyCharacteristicChangedByInstanceId(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
            @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex,
            @RpcParameter(name = "instanceId") Integer instanceId,
            @RpcParameter(name = "confirm") Boolean confirm) throws Exception {

        BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
        if (gattServer == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices =
                mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT_SERVER);
        if (connectedDevices == null) {
            throw new Exception(
                    "Connected device list empty for gattServerIndex:" + Integer.toString(
                        gattServerIndex));
        }
        BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
        if (bluetoothDevice == null) {
            throw new Exception(
                    "Invalid bluetoothDeviceIndex: " + Integer.toString(bluetoothDeviceIndex));
        }

        for (BluetoothGattCharacteristic mGattChar : mCharacteristicList.values()) {
            if (mGattChar.getInstanceId() == instanceId) {
                        Log.i("Found Characteristic to get value. instanceId: "
                        + Integer.toString(instanceId)
                        + " UUID: " + mGattChar.getUuid().toString());
                gattServer.notifyCharacteristicChanged(bluetoothDevice, mGattChar, confirm);
            }
        }
    }

    /**
     * Create a new bluetooth gatt service
     *
     * @param uuid the UUID that characterises the service
     * @param serviceType the service type
     * @return The index of the new bluetooth gatt service
     */
    @Rpc(description = "Create new bluetooth gatt service")
    public int gattServerCreateService(@RpcParameter(name = "uuid") String uuid,
            @RpcParameter(name = "serviceType") Integer serviceType) {
        sGattServiceCount += 1;
        int index = sGattServiceCount;
        mGattServiceList.put(index, new BluetoothGattService(UUID.fromString(uuid), serviceType));
        return index;
    }

    /**
     * Add a characteristic to a bluetooth gatt service
     *
     * @param index the bluetooth gatt service index
     * @param serviceUuid the service Uuid to get
     * @param characteristicIndex the character index to use
     * @throws Exception
     */
    @Rpc(description = "Add a characteristic to a bluetooth gatt service")
    public void gattServiceAddCharacteristic(
            @RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "serviceUuid") String serviceUuid,
            @RpcParameter(name = "characteristicIndex") Integer characteristicIndex)
            throws Exception {
        if (mBluetoothGattServerList.get(index) != null
                && mBluetoothGattServerList.get(index).getService(
                    UUID.fromString(serviceUuid)) != null
                && mCharacteristicList.get(characteristicIndex) != null) {
            mBluetoothGattServerList.get(index).getService(UUID.fromString(serviceUuid))
                    .addCharacteristic(mCharacteristicList.get(characteristicIndex));
        } else {
            if (mBluetoothGattServerList.get(index) == null) {
                throw new Exception("Invalid index input:" + index);
            } else if (mCharacteristicList.get(characteristicIndex) == null) {
                throw new Exception("Invalid characteristicIndex input:" + characteristicIndex);
            } else {
                throw new Exception("Invalid serviceUuid input:" + serviceUuid);
            }
        }
    }

    /**
     * Add a characteristic to a bluetooth gatt service
     *
     * @param index the bluetooth gatt service to add a characteristic to
     * @param characteristicIndex the characteristic to add
     * @throws Exception
     */
    @Rpc(description = "Add a characteristic to a bluetooth gatt service")
    public void gattServerAddCharacteristicToService(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "characteristicIndex") Integer characteristicIndex

    ) throws Exception {
        if (mGattServiceList.get(index) != null) {
            if (mCharacteristicList.get(characteristicIndex) != null) {
                mGattServiceList.get(index).addCharacteristic(mCharacteristicList.get(
                        characteristicIndex));
            } else {
                throw new Exception("Invalid index input:" + index);
            }
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Close a bluetooth gatt
     *
     * @param index the bluetooth gatt index to close
     * @throws Exception
     */
    @Rpc(description = "Close a bluetooth gatt")
    public void gattServerClose(@RpcParameter(name = "index") Integer index) throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            mBluetoothGattServerList.get(index).close();
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Get a list of Bluetooth Devices connnected to the bluetooth gatt
     *
     * @param index the bluetooth gatt index
     * @return List of BluetoothDevice Objects
     * @throws Exception
     */
    @Rpc(description = "Get a list of Bluetooth Devices connnected to the bluetooth gatt")
    public List<BluetoothDevice> gattGetConnectedDevices(
            @RpcParameter(name = "index") Integer index)
            throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            return mBluetoothGattServerList.get(index).getConnectedDevices();
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Read the current transmitter PHY and receiver PHY of the connection.
     *
     * @param gattServerIndex the bluetooth gatt index
     * @throws Exception
     */
    @Rpc(description = "Read PHY")
    public void gattServerReadPhy(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
            @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex)
                throws Exception {
        BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
        if (gattServer == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices = mGattServerDiscoveredDevicesList.get(
                gattServerIndex);
        if (connectedDevices == null) {
            throw new Exception(
                    "Connected device list empty for gattServerIndex:" + Integer.toString(
                        gattServerIndex));
        }
        BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
        if (bluetoothDevice == null) {
            throw new Exception(
                    "Invalid bluetoothDeviceIndex: " + Integer.toString(bluetoothDeviceIndex));
        }

        if (mBluetoothGattServerList.get(gattServerIndex) != null) {
            mBluetoothGattServerList.get(gattServerIndex).readPhy(bluetoothDevice);
        } else {
            throw new Exception("Invalid index input:" + gattServerIndex);
        }
    }

    /**
     * Set the preferred connection PHY.
     *
     * @param gattServerIndex the bluetooth gatt index
     * @throws Exception
     */
    @Rpc(description = "Set the preferred connection PHY")
    public void gattServerSetPreferredPhy(
            @RpcParameter(name = "gattServerIndex") Integer gattServerIndex,
            @RpcParameter(name = "bluetoothDeviceIndex") Integer bluetoothDeviceIndex,
            @RpcParameter(name = "txPhy") Integer txPhy,
            @RpcParameter(name = "rxPhy") Integer rxPhy,
            @RpcParameter(name = "txPhy") Integer phyOptions) throws Exception {
        BluetoothGattServer gattServer = mBluetoothGattServerList.get(gattServerIndex);
        if (gattServer == null) {
            throw new Exception("Invalid gattServerIndex: " + Integer.toString(gattServerIndex));
        }
        List<BluetoothDevice> connectedDevices = mGattServerDiscoveredDevicesList.get(
                gattServerIndex);
        if (connectedDevices == null) {
            throw new Exception(
                    "Connected device list empty for gattServerIndex:" + Integer.toString(
                        gattServerIndex));
        }
        BluetoothDevice bluetoothDevice = connectedDevices.get(bluetoothDeviceIndex);
        if (bluetoothDevice == null) {
            throw new Exception(
                    "Invalid bluetoothDeviceIndex: " + Integer.toString(bluetoothDeviceIndex));
        }

        if (mBluetoothGattServerList.get(gattServerIndex) != null) {
            mBluetoothGattServerList.get(gattServerIndex)
                .setPreferredPhy(bluetoothDevice, txPhy, rxPhy, phyOptions);
        } else {
            throw new Exception("Invalid index input:" + gattServerIndex);
        }
    }

    /**
     * Get GATT Server UUID by characteristic index
     *
     * @param charIndex of the characteristic
     * @return String Uuid
     * @throws Exception
     */
    @Rpc(description = "Get UUID of the input characteristic")
    public String gattServerGetCharacteristicUuid(
            @RpcParameter(name = "charIndex") Integer charIndex)
            throws Exception {
        BluetoothGattCharacteristic gattChar = mCharacteristicList.get(charIndex);
        if (gattChar == null) {
            throw new Exception("Invalid index input: " + charIndex);
        }
        return gattChar.getUuid().toString();
    }

    /**
     * Get GATT Server UUID by characteristic index
     *
     * @param charIndex of the characteristic
     * @return Integer instanceId
     * @throws Exception
     */
    @Rpc(description = "Get instanceId of the input characteristic")
    public Integer gattServerGetCharacteristicInstanceId(
            @RpcParameter(name = "charIndex") Integer charIndex)
            throws Exception {
        BluetoothGattCharacteristic gattChar = mCharacteristicList.get(charIndex);
        if (gattChar == null) {
            throw new Exception("Invalid index input: " + charIndex);
        }
        return gattChar.getInstanceId();
    }

    /**
     * Get the service from an input UUID
     *
     * @param index the bluetooth gatt index
     * @return BluetoothGattService related to the bluetooth gatt
     * @throws Exception
     */
    @Rpc(description = "Get the service from an input UUID")
    public ArrayList<String> gattGetServiceUuidList(@RpcParameter(name = "index") Integer index)
            throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            ArrayList<String> serviceUuidList = new ArrayList<String>();
            for (BluetoothGattService service : mBluetoothGattServerList.get(index).getServices()) {
                serviceUuidList.add(service.getUuid().toString());
            }
            return serviceUuidList;
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Get the service from an input UUID
     *
     * @param index the bluetooth gatt index
     * @param uuid the String uuid that matches the service
     * @return BluetoothGattService related to the bluetooth gatt
     * @throws Exception
     */
    @Rpc(description = "Get the service from an input UUID")
    public BluetoothGattService gattGetService(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "uuid") String uuid) throws Exception {
        if (mBluetoothGattServerList.get(index) != null) {
            return mBluetoothGattServerList.get(index).getService(UUID.fromString(uuid));
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Add a descriptor to a bluetooth gatt characteristic
     *
     * @param index the bluetooth gatt characteristic to add a descriptor to
     * @param descriptorIndex the descritor index to add to the characteristic
     * @throws Exception
     */
    @Rpc(description = "add descriptor to blutooth gatt characteristic")
    public void gattServerCharacteristicAddDescriptor(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "descriptorIndex") Integer descriptorIndex) throws Exception {
        if (mCharacteristicList.get(index) != null) {
            if (mDescriptorList.get(descriptorIndex) != null) {
                mCharacteristicList.get(index).addDescriptor(mDescriptorList.get(descriptorIndex));
            } else {
                throw new Exception("Invalid descriptorIndex input:" + descriptorIndex);
            }
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Create a new Characteristic object
     *
     * @param characteristicUuid uuid The UUID for this characteristic
     * @param property Properties of this characteristic
     * @param permission permissions Permissions for this characteristic
     * @return
     */
    @Rpc(description = "Create a new Characteristic object")
    public int gattServerCreateBluetoothGattCharacteristic(
            @RpcParameter(name = "characteristicUuid") String characteristicUuid,
            @RpcParameter(name = "property") Integer property,
            @RpcParameter(name = "permission") Integer permission) {
        sCharacteristicCount += 1;
        int index = sCharacteristicCount;
        BluetoothGattCharacteristic characteristic =
                new BluetoothGattCharacteristic(
                    UUID.fromString(characteristicUuid), property, permission);
        mCharacteristicList.put(index, characteristic);
        return index;
    }

    /**
     * Set value to a bluetooth gatt characteristic
     *
     * @deprecated Use {@link #gattServerCharacteristicSetValueByInstanceId(
     * instanceId, value)} instead.
     * @param index the bluetooth gatt characteristic
     * @param value value
     * @throws Exception
     */
    @Deprecated
    @Rpc(description = "Set byte value to a Characteristic")
    public void gattServerCharacteristicSetValue(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "value") byte[] value) throws Exception {
        if (mCharacteristicList.get(index) != null) {
            mCharacteristicList.get(index).setValue(value);
            } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Set value to a bluetooth gatt characteristic by instance id
     *
     * @param index the bluetooth gatt characteristic by instance id
     * @param value value
     * @throws Exception
     */
    @Rpc(description = "Set byte value to a Characteristic by instance id")
    public boolean gattServerCharacteristicSetValueByInstanceId(
            @RpcParameter(name = "instanceId") Integer instanceId,
            @RpcParameter(name = "value") byte[] value) throws Exception {
        for (BluetoothGattCharacteristic mGattChar : mCharacteristicList.values()) {
            //test this to be sure
            if (mGattChar.getInstanceId() == instanceId) {
                return mGattChar.setValue(value);
            }
        }
        throw new Exception("Cannot find instance ID:" + instanceId);
    }

    /**
     * Set value to a bluetooth gatt characteristic
     *
     * @param index the bluetooth gatt characteristic
     * @param value value
     * @throws Exception
     */
    @Rpc(description = "Set Characteristic Byte Value")
    public boolean gattServerCharacteristicSetByteValue(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "value") byte[] value) throws Exception {
        if (mCharacteristicList.get(index) != null) {
            return mCharacteristicList.get(index).setValue(value);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Set value to a bluetooth gatt descriptor
     *
     * @param index the bluetooth gatt descriptor
     * @param value byte[] value to set
     * @throws Exception
     */
    @Rpc(description = "Set Characteristic Byte Value")
    public boolean gattServerDescriptorSetByteValue(
            @RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "value") byte[] value) throws Exception {
        if (mDescriptorList.get(index) != null) {
            return mDescriptorList.get(index).setValue(value);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Get Read value by instance ID
     *
     * @param instanceId of the Characteristic of the Descriptor to get the value of
     * @throws Exception
     */
    @Rpc(description = "Returns the read value of a matching instanceId")
    public byte[] gattServerGetReadValueByInstanceId(
            @RpcParameter(name = "instanceId") Integer instanceId)
            throws Exception {
        for (BluetoothGattCharacteristic mGattChar : mCharacteristicList.values()) {
            if (mGattChar.getInstanceId() == instanceId) {
                        Log.i("Found Characteristic to get value. instanceId: "
                        + Integer.toString(instanceId)
                        + " UUID: " + mGattChar.getUuid().toString());
                return mGattChar.getValue();
            }
            List<BluetoothGattDescriptor> descList = mGattChar.getDescriptors();
            for (BluetoothGattDescriptor mGattDesc : descList) {
                if (mGattDesc.getInstanceId() == instanceId) {
                    Log.i("Found Descriptor to get value. instanceId: "
                        + Integer.toString(instanceId)
                        + " UUID: " + mGattDesc.getUuid().toString());
                    return mGattDesc.getValue();
                }
            }
        }
        throw new Exception("Cannot find instance ID:" + instanceId);
    }

    /**
     * Set value by instance ID
     *
     * @param instanceId of the Characteristic of the Descriptor to get the value of
     * @value value set bytearray value
     * @throws Exception
     */
    @Rpc(description = "Sets the value of a Characteristic or Descriptor by instance id")
    public boolean gattServerSetByteArrayValueByInstanceId(
            @RpcParameter(name = "instanceId") Integer instanceId,
            @RpcParameter(name = "value") byte[] value)
            throws Exception {
        for (BluetoothGattCharacteristic mGattChar : mCharacteristicList.values()) {
            if (mGattChar.getInstanceId() == instanceId) {
                        Log.i("Found Characteristic to get value. instanceId: "
                        + Integer.toString(instanceId)
                        + " UUID: " + mGattChar.getUuid().toString());
                return mGattChar.setValue(value);
            }
            List<BluetoothGattDescriptor> descList = mGattChar.getDescriptors();
            for (BluetoothGattDescriptor mGattDesc : descList) {
                if (mGattDesc.getInstanceId() == instanceId) {
                    Log.i("Found Descriptor to set value. instanceId: "
                        + Integer.toString(instanceId)
                        + " UUID: " + mGattDesc.getUuid().toString());
                    return mGattDesc.setValue(value);
                }
            }
        }
        throw new Exception("Cannot find instance ID:" + instanceId);
    }

    /**
     * Set BluetoothGattService instance ID to input value
     *
     * @param index the bluetooth gatt service
     * @param instanceId instanceId
     * @throws Exception
     */
    @Rpc(description = "GATT Server Set Instance ID of Service")
    public void gattServerServiceSetInstanceId(
            @RpcParameter(name = "serviceIndex") Integer serviceIndex,
            @RpcParameter(name = "instanceId") Integer instanceId) throws Exception {
        if (mGattServiceList.get(serviceIndex) == null) {
            throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
        }
        Class bluetoothGattServiceClass = Class.forName("android.bluetooth.BluetoothGattService");
        Method setInstanceIdMethod = bluetoothGattServiceClass.getMethod(
            "setInstanceId", int.class);
        setInstanceIdMethod.invoke(mGattServiceList.get(serviceIndex), instanceId);
    }

    /**
     * GATT Server set the number of handles to reserve for this service
     *
     * @param index the bluetooth gatt service
     * @param numHandles number of handles to reserve
     * @throws Exception
     */
    @Rpc(description = "GATT Server Set the number of handles to reserve for this service")
    public void gattServerServiceSetHandlesToReserve(
            @RpcParameter(name = "serviceIndex") Integer serviceIndex,
            @RpcParameter(name = "numHandles") Integer numHandles) throws Exception {
        if (mGattServiceList.get(serviceIndex) == null) {
            throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
        }
        Class bluetoothGattServiceClass = Class.forName("android.bluetooth.BluetoothGattService");
        Method setHandlesMethod = bluetoothGattServiceClass.getMethod(
            "setHandles", int.class);
        setHandlesMethod.invoke(mGattServiceList.get(serviceIndex), numHandles);
    }

    /**
     * GATT Server set service advertise perferred value
     *
     * @param index the bluetooth gatt service
     * @param isPreferred if advertisement is preferred or not
     * @throws Exception
     */
    @Rpc(description = "GATT Server Set the number of handles to reserve for this service")
    public void gattServerServiceIsAdvertisePreferred(
            @RpcParameter(name = "serviceIndex") Integer serviceIndex,
            @RpcParameter(name = "isPreferred") Boolean isPreferred) throws Exception {
        if (mGattServiceList.get(serviceIndex) == null) {
            throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
        }
        Class bluetoothGattServiceClass = Class.forName("android.bluetooth.BluetoothGattService");
        Method setAdvertisePreferredMethod = bluetoothGattServiceClass.getMethod(
            "setAdvertisePrefereed", boolean.class);
        setAdvertisePreferredMethod.invoke(mGattServiceList.get(serviceIndex), isPreferred);
    }

    /**
     * GATT Service add included service.
     *
     * @param index the bluetooth gatt service
     * @param serviceIncludedIndex index of the service to be included
     * @throws Exception
     */
    @Rpc(description = "Gatt Server add included service")
    public void gattServerServiceaddIncludedService(
            @RpcParameter(name = "serviceIndex") Integer serviceIndex,
            @RpcParameter(name = "serviceIncludedIndex") Integer serviceIncludedIndex)
            throws Exception {
        if (mGattServiceList.get(serviceIndex) == null) {
            throw new Exception("Invalid serviceIndex input:" + Integer.toString(serviceIndex));
        }
        if (mGattServiceList.get(serviceIncludedIndex) == null) {
            throw new Exception("Invalid serviceIncludedIndex input:" + Integer.toString(
                serviceIncludedIndex));
        }
        Class bluetoothGattServiceClass = Class.forName("android.bluetooth.BluetoothGattService");
        Method addIncludedServiceMethod = bluetoothGattServiceClass.getMethod(
            "addIncludedService", BluetoothGattService.class);
        addIncludedServiceMethod.invoke(
            mGattServiceList.get(serviceIndex), mGattServiceList.get(serviceIncludedIndex));
    }

    /**
     * Set value to a bluetooth gatt characteristic
     *
     * @param index the bluetooth gatt characteristic
     * @param value value
     * @throws Exception
     */
    @Rpc(description = "add descriptor to blutooth gatt characteristic")
    public boolean gattServerCharacteristicSetStringValue(
            @RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "value") String value) throws Exception {
        if (mCharacteristicList.get(index) != null) {
            return mCharacteristicList.get(index).setValue(value);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Set value to a bluetooth gatt characteristic
     *
     * @param index the bluetooth gatt characteristic
     * @param value value
     * @throws Exception
     */
    @Rpc(description = "add descriptor to blutooth gatt characteristic")
    public boolean gattServerCharacteristicSetIntValue(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "value") Integer value,
            @RpcParameter(name = "type") Integer type,
            @RpcParameter(name = "offset") Integer offset)
            throws Exception {
        if (mCharacteristicList.get(index) != null) {
            return mCharacteristicList.get(index).setValue(value, type, offset);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Set the instance id of the Bluetooth Gatt Characteristic
     *
     * @param index the bluetooth gatt characteristic
     * @param instanceId the instanceId to set
     * @throws Exception
     */
    @Rpc(description = "Set Caracteristic Instance id")
    public void gattServerCharacteristicSetInstanceId(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "instanceId") Integer instanceId)
            throws Exception {
        if (mCharacteristicList.get(index) != null) {
            mCharacteristicList.get(index).setInstanceId(instanceId);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Set the instance id of the Bluetooth Gatt Descriptor
     *
     * @param index the bluetooth gatt descriptor
     * @param instanceId the instanceId to set
     * @throws Exception
     */
    @Rpc(description = "Set Descriptor Instance Id")
    public void gattServerDescriptorSetInstanceId(@RpcParameter(name = "index") Integer index,
            @RpcParameter(name = "instanceId") Integer instanceId)
            throws Exception {
        if (mDescriptorList.get(index) != null) {
            Class bluetoothGattDescriptorClass = Class.forName(
                "android.bluetooth.BluetoothGattDescriptor");
            Method setInstanceIdMethod = bluetoothGattDescriptorClass.getMethod(
                "setInstanceId", int.class);
            setInstanceIdMethod.invoke(
                mDescriptorList.get(index), instanceId);
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Get the instance id of the Bluetooth Gatt Characteristic
     *
     * @param index the bluetooth gatt characteristic
     * @throws Exception
     * @return the instance id of the characteristic
     */
    @Rpc(description = "add descriptor to blutooth gatt characteristic")
    public int gattServerCharacteristicGetInstanceId(
            @RpcParameter(name = "index") Integer index)
            throws Exception {
        if (mCharacteristicList.get(index) != null) {
            return mCharacteristicList.get(index).getInstanceId();
        } else {
            throw new Exception("Invalid index input:" + index);
        }
    }

    /**
     * Create a new GattCallback object
     *
     * @return the index of the callback object
     */
    @Rpc(description = "Create a new GattCallback object")
    public Integer gattServerCreateGattServerCallback() {
        sGattServerCallbackCount += 1;
        int index = sGattServerCallbackCount;
        mBluetoothGattServerCallbackList.put(index, new BtGattServerCallback(index));
        return index;
    }

    /**
     * Create a new Descriptor object
     *
     * @param descriptorUuid the UUID for this descriptor
     * @param permissions Permissions for this descriptor
     * @return the index of the Descriptor object
     */
    @Rpc(description = "Create a new Descriptor object")
    public int gattServerCreateBluetoothGattDescriptor(
            @RpcParameter(name = "descriptorUuid") String descriptorUuid,
            @RpcParameter(name = "permissions") Integer permissions) {
        sDescriptorCount += 1;
        int index = sDescriptorCount;
        BluetoothGattDescriptor descriptor =
                new BluetoothGattDescriptor(UUID.fromString(descriptorUuid), permissions);
        mDescriptorList.put(index, descriptor);
        return index;
    }

    private class BtGattServerCallback extends BluetoothGattServerCallback {
        private final Bundle mResults;
        private final int mIndex;
        private final String mEventType;

        BtGattServerCallback(int idx) {
            mResults = new Bundle();
            mEventType = "GattServer";
            mIndex = idx;
        }

        @Override
        public void onServiceAdded(int status, BluetoothGattService service) {
            Log.d("gatt_server change onServiceAdded " + mEventType + " " + mIndex);
            mResults.putString("serviceUuid", service.getUuid().toString());
            mResults.putInt("instanceId", service.getInstanceId());
            mEventFacade.postEvent(mEventType + mIndex + "onServiceAdded", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset,
                BluetoothGattCharacteristic characteristic) {
            Log.d("gatt_server change onCharacteristicReadRequest " + mEventType + " " + mIndex);
            mResults.putInt("requestId", requestId);
            mResults.putInt("offset", offset);
            mResults.putInt("instanceId", characteristic.getInstanceId());
            mResults.putInt("properties", characteristic.getProperties());
            mResults.putString("uuid", characteristic.getUuid().toString());
            mResults.putInt("permissions", characteristic.getPermissions());
            mEventFacade.postEvent(
                    mEventType + mIndex + "onCharacteristicReadRequest", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId,
                BluetoothGattCharacteristic characteristic, boolean preparedWrite,
                boolean responseNeeded, int offset, byte[] value) {
            Log.d("gatt_server change onCharacteristicWriteRequest " + mEventType + " " + mIndex);
            mResults.putInt("requestId", requestId);
            mResults.putInt("offset", offset);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putBoolean("preparedWrite", preparedWrite);
            mResults.putBoolean("responseNeeded", responseNeeded);
            mResults.putByteArray("value", value);
            mResults.putInt("instanceId", characteristic.getInstanceId());
            mResults.putInt("properties", characteristic.getProperties());
            mResults.putString("uuid", characteristic.getUuid().toString());
            mResults.putInt("permissions", characteristic.getPermissions());
            mEventFacade.postEvent(
                    mEventType + mIndex + "onCharacteristicWriteRequest", mResults.clone());
            mResults.clear();

        }

        @Override
        public void onDescriptorReadRequest(BluetoothDevice device, int requestId, int offset,
                BluetoothGattDescriptor descriptor) {
            Log.d("gatt_server change onDescriptorReadRequest " + mEventType + " " + mIndex);
            mResults.putInt("requestId", requestId);
            mResults.putInt("offset", offset);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("instanceId", descriptor.getInstanceId());
            mResults.putInt("permissions", descriptor.getPermissions());
            mResults.putString("uuid", descriptor.getUuid().toString());
            mEventFacade.postEvent(
                    mEventType + mIndex + "onDescriptorReadRequest", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onDescriptorWriteRequest(BluetoothDevice device, int requestId,
                BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded,
                int offset, byte[] value) {
            Log.d("gatt_server change onDescriptorWriteRequest " + mEventType + " " + mIndex);
            mResults.putInt("requestId", requestId);
            mResults.putInt("offset", offset);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putBoolean("preparedWrite", preparedWrite);
            mResults.putBoolean("responseNeeded", responseNeeded);
            mResults.putByteArray("value", value);
            mResults.putInt("instanceId", descriptor.getInstanceId());
            mResults.putInt("permissions", descriptor.getPermissions());
            mResults.putString("uuid", descriptor.getUuid().toString());
            mEventFacade.postEvent(
                    mEventType + mIndex + "onDescriptorWriteRequest", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onExecuteWrite(BluetoothDevice device, int requestId, boolean execute) {
            Log.d("gatt_server change onExecuteWrite " + mEventType + " " + mIndex);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("requestId", requestId);
            mResults.putBoolean("execute", execute);
            mEventFacade.postEvent(mEventType + mIndex + "onExecuteWrite", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onNotificationSent(BluetoothDevice device, int status) {
            Log.d("gatt_server change onNotificationSent " + mEventType + " " + mIndex);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("status", status);
            mEventFacade.postEvent(mEventType + mIndex + "onNotificationSent", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
            Log.d("gatt_server change onConnectionStateChange " + mEventType + " " + mIndex);
            if (newState == BluetoothProfile.STATE_CONNECTED) {
                Log.d("State Connected to mac address " + device.getAddress() + " status "
                        + status);
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                Log.d("State Disconnected from mac address "
                        + device.getAddress() + " status " + status);
            }
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("status", status);
            mResults.putInt("newState", newState);
            mEventFacade.postEvent(
                    mEventType + mIndex + "onConnectionStateChange", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onMtuChanged(BluetoothDevice device, int mtu) {
            Log.d("gatt_server change onMtuChanged " + mEventType + " " + mIndex);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("MTU", mtu);
            mEventFacade.postEvent(mEventType + mIndex + "onMtuChanged", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onPhyRead(BluetoothDevice device, int txPhy, int rxPhy, int status) {
            Log.d("gatt_server change onPhyRead " + mEventType + " " + mIndex);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("TxPhy", txPhy);
            mResults.putInt("RxPhy", rxPhy);
            mResults.putInt("Status", status);
            mEventFacade.postEvent(mEventType + mIndex + "onPhyRead", mResults.clone());
            mResults.clear();
        }

        @Override
        public void onPhyUpdate(BluetoothDevice device, int txPhy, int rxPhy, int status) {
            Log.d("gatt_server change onPhyUpdate " + mEventType + " " + mIndex);
            mResults.putParcelable("BluetoothDevice", device);
            mResults.putInt("TxPhy", txPhy);
            mResults.putInt("RxPhy", rxPhy);
            mResults.putInt("Status", status);
            mEventFacade.postEvent(mEventType + mIndex + "onPhyUpdate", mResults.clone());
            mResults.clear();
        }

        public void onConnectionUpdated(BluetoothDevice device, int interval, int latency,
                                            int timeout, int status) {
            Log.d("gatt_server change onConnecitonUpdated " + mEventType + " " + mIndex
                    + ", interval: " + interval + ", latency: " + latency
                    + ", timeout: " + timeout + ", status: " + status);

            mResults.putInt("Status", status);
            mResults.putInt("Interval", interval);
            mResults.putInt("Latency", latency);
            mResults.putInt("Timeout", timeout);
            mEventFacade.postEvent(mEventType + mIndex + "onConnectionUpdated", mResults.clone());
            mResults.clear();
        }

    }

    @Override
    public void shutdown() {
        if (!mBluetoothGattServerList.isEmpty()) {
            if (mBluetoothGattServerList.values() != null) {
                for (BluetoothGattServer mBluetoothGattServer : mBluetoothGattServerList.values()) {
                    mBluetoothGattServer.close();
                }
            }
        }
    }
}