/******************************************************************************
 *
 *  Copyright (C) 2013-2014 Cypress Semiconductor
 *
 *  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.rockchip.smart.rockhome.blue;

import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.util.Log;

import java.util.ArrayDeque;
import java.util.List;
import java.util.Queue;
import java.util.UUID;

/**
 * Helper functions to work with services and characteristics
 */
public class GattUtils {
    private static final String TAG = Constants.TAG_PREFIX + "GattUtils";

    /**
     * Queue for ensuring read/write requests are serialized so that each
     * read/write completes for the the next read/write request is performed
     */
    public static class RequestQueue {

        /**
         * Internal object used to manage a specific read or write request
         */
        private class GattRequest {
            private static final int REQUEST_READ_CHAR = 1;
            private static final int REQUEST_WRITE_CHAR = 2;
            private static final int REQUEST_READ_DESC = 11;
            private static final int REQUEST_WRITE_DESC = 12;

            private final int mRequestType;
            private final BluetoothGatt mGatt;
            private final BluetoothGattCharacteristic mCharacteristic;
            private final BluetoothGattDescriptor mDescriptor;
            private final byte[] mValue;

            public GattRequest(int requestType, BluetoothGatt gatt,
                               BluetoothGattCharacteristic characteristic) {
                this(requestType, gatt, characteristic, null);
            }

            public GattRequest(int requestType, BluetoothGatt gatt,
                    BluetoothGattCharacteristic characteristic, byte[] value) {
                mGatt = gatt;
                mCharacteristic = characteristic;
                mDescriptor = null;
                mRequestType = requestType;
                mValue = value;
            }

            public GattRequest(int requestType, BluetoothGatt gatt,
                               BluetoothGattDescriptor descriptor) {
                this(requestType, gatt, descriptor, null);
            }

            public GattRequest(int requestType, BluetoothGatt gatt,
                    BluetoothGattDescriptor descriptor, byte[] value) {
                mGatt = gatt;
                mDescriptor = descriptor;
                mCharacteristic = null;
                mRequestType = requestType;
                mValue = value;
            }
        }

        // Queue containing requests
        private final Queue<GattRequest> mRequestQueue = new ArrayDeque<GattRequest>();

        // If true, the request queue is currently processing read/write
        // requests
        private boolean mIsRunning;

        /**
         * Add a read descriptor request to the queue
         *
         * @param gatt
         * @param descriptor
         */
        public synchronized void addReadDescriptor(BluetoothGatt gatt,
                BluetoothGattDescriptor descriptor) {
             Log.d(TAG, "addReadDescriptor(),descriptor: " + descriptor);
            if (gatt == null || descriptor == null) {
                Log.d(TAG, "addReadDescriptor(): invalid data");
                return;
            }
            mRequestQueue.add(new GattRequest(GattRequest.REQUEST_READ_DESC, gatt, descriptor));
        }

        public synchronized void addWriteDescriptor(BluetoothGatt gatt,
                                                    BluetoothGattDescriptor descriptor) {
            addWriteDescriptor(gatt, descriptor, null);
        }

        /**
         * Add a write descriptor request to the queue
         *
         * @param gatt
         * @param descriptor
         */
        public synchronized void addWriteDescriptor(BluetoothGatt gatt,
                BluetoothGattDescriptor descriptor, byte[] value) {
            Log.d(TAG, "addWriteDescriptor(),descriptor: " + descriptor);
            if (gatt == null || descriptor == null) {
                Log.d(TAG, "addWriteDescriptor(): invalid data");
                return;
            }
            mRequestQueue.add(new GattRequest(GattRequest.REQUEST_WRITE_DESC, gatt, descriptor, value));
        }

        /**
         * Add a read characteristic request to the queue
         *
         * @param gatt
         * @param characteristic
         */
        public synchronized void addReadCharacteristic(BluetoothGatt gatt,
                BluetoothGattCharacteristic characteristic) {
             Log.d(TAG, "addReadCharacteristic(),characteristic: " + characteristic);
            if (gatt == null || characteristic == null) {
                Log.d(TAG, "addReadCharacteristic(): invalid data");
                return;
            }
            mRequestQueue.add(new GattRequest(GattRequest.REQUEST_READ_CHAR, gatt, characteristic));
        }

        /**
         * Add a write characteristic request to the queue
         *
         * @param gatt
         * @param characteristic
         */
        public synchronized void addWriteCharacteristic(BluetoothGatt gatt,
                BluetoothGattCharacteristic characteristic) {
            Log.d(TAG, "addWriteCharacteristic(),characteristic: " + characteristic);
            if (gatt == null || characteristic == null) {
                Log.d(TAG, "addWriteCharacteristic(): invalid data");
                return;
            }
            mRequestQueue
                    .add(new GattRequest(GattRequest.REQUEST_WRITE_CHAR, gatt, characteristic));
        }

        /**
         * Clear all the requests in the queue
         */
        public void clear() {
            mRequestQueue.clear();
        }

        /**
         * Get the next queued request, if any, and perform the requested
         * operation
         */
        public void next() {
            GattRequest request = null;
            synchronized (this) {
                Log.d(TAG, "next: queue size=" + mRequestQueue.size() + ", mIsRunning= " + mIsRunning);
                request = mRequestQueue.poll();
                if (request == null) {
                    Log.d(TAG, "next: no request()");
                    mIsRunning = false;
                    return;
                }
            }

            if (request.mRequestType == GattRequest.REQUEST_READ_CHAR) {
                request.mGatt.readCharacteristic(request.mCharacteristic);
            } else if (request.mRequestType == GattRequest.REQUEST_WRITE_CHAR) {
                request.mGatt.writeCharacteristic(request.mCharacteristic);
            } else if (request.mRequestType == GattRequest.REQUEST_READ_DESC) {
                request.mGatt.readDescriptor(request.mDescriptor);
            } else if (request.mRequestType == GattRequest.REQUEST_WRITE_DESC) {
                if (request.mValue != null) {
                    request.mDescriptor.setValue(request.mValue);
                }
                BluetoothGattDescriptor descriptor = request.mDescriptor;
                StringBuilder builder = new StringBuilder();
                builder.append("{");
                for (int i=0; i<descriptor.getValue().length; i++) {
                    builder.append(descriptor.getValue()[i]).append(",");
                }
                builder.append("}");
                Log.d(TAG, "Bluetooth GattRequest.REQUEST_WRITE_DESC " + builder.toString());
                request.mGatt.writeDescriptor(request.mDescriptor);
            }
        }

        /**
         * Start processing the queued requests, if not already started.
         * Otherwise, this method does nothing if processing already started
         */
        public void execute() {
            synchronized (this) {
                Log.d(TAG, "execute: queue size=" + mRequestQueue.size() + ", mIsRunning= "
                        + mIsRunning);
                if (mIsRunning) {
                    return;
                }
                mIsRunning = true;
            }
            next();
        }
    }

    /**
     * Create a read/write request queue
     *
     * @return
     */
    public static RequestQueue createRequestQueue() {
        return new RequestQueue();
    }

    /**
     * Get a characteristic with the specified service UUID and characteristic
     * UUID
     *
     * @param gatt
     * @param serviceUuid
     * @param characteristicUuid
     * @return
     */
    public static BluetoothGattCharacteristic getCharacteristic(BluetoothGatt gatt,
                                                                UUID serviceUuid, UUID characteristicUuid) {
            Log.d(TAG, "getCharacteristic,gatt: " + gatt + " serviceUuid: " + serviceUuid);
        if (gatt == null) {
            return null;
        }
        BluetoothGattService service = gatt.getService(serviceUuid);
        if (service == null) {
            return null;
        }
        return service.getCharacteristic(characteristicUuid);
    }

    /**
     * Get a descriptor with the specified service UUID, characteristic UUID,
     * and descriptor UUID
     *
     * @param gatt
     * @param serviceUuid
     * @param characteristicUuid
     * @param descriptorUuid
     * @return
     */
    public static BluetoothGattDescriptor getDescriptor(BluetoothGatt gatt, UUID serviceUuid,
                                                        UUID characteristicUuid, UUID descriptorUuid) {
        Log.d(TAG, "getDescriptor,descriptorUuid: " + descriptorUuid);
        BluetoothGattCharacteristic characteristic = getCharacteristic(gatt, serviceUuid,
                characteristicUuid);
        if (characteristic != null) {
            return characteristic.getDescriptor(descriptorUuid);
        }
        return null;
    }

    /**
     * Converts a byte array into a long value
     *
     * @param bytes
     * @param bytesToRead
     * @param offset
     * @return
     */
    public static long unsignedBytesToLong(byte[] bytes, int bytesToRead, int offset) {
        int shift = 0;
        long l = 0;


        if (bytes != null) {
            if (bytesToRead > bytes.length)
                bytesToRead = bytes.length;

            for (int i = offset; i < bytesToRead; i++) {
                Log.d(TAG, "unsignedBytesToLong: " + bytes[i]);
                l = l + ((long) (bytes[i] & 0xFF) << (8 * shift++));
            }
        }
        return l;
    }

    public void setCharacteristicNotification(BluetoothGatt gatt,
                                              BluetoothGattCharacteristic characteristic,
                                              boolean enabled) {
        if ( gatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        gatt.setCharacteristicNotification(characteristic, enabled);
        List<BluetoothGattDescriptor> descriptors = characteristic.getDescriptors();
        for(BluetoothGattDescriptor dp:descriptors){
            dp.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
            gatt.writeDescriptor(dp);
        }
    }
}