// Ensures Bluetooth is available on the device and it is enabled. If not,
// displays a dialog requesting user permission to enable Bluetooth.
if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
    Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
} else {
    // Si el dispositivo tiene bluetooth o el bluetooth esta encendido, hacer visible el boton de conectar y de desconectar de la interfaz de usuario.
    connectBtn.setVisibility(View.VISIBLE);
    disconectBtn.setVisibility(View.VISIBLE);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // Check which request we're responding to
    // just UI topics
    if (requestCode == REQUEST_ENABLE_BT) {
        if (resultCode == RESULT_OK) {
            Log.w(TAG, "Bluetooth enabled");
            Toast.makeText(this, "Bluetooth enabled", Toast.LENGTH_SHORT).show();
            connectBtn.setVisibility(View.VISIBLE);
            disconectBtn.setVisibility(View.VISIBLE);
        }
        else {
            // Si no se pudo enceder el bluetooth o el usuario no lo permitio, desactivar los botones de conectar y de desconectar.
            connectBtn.setVisibility(View.VISIBLE);
            disconectBtn.setVisibility(View.VISIBLE);
            connectBtn.setEnabled(false);
            disconectBtn.setEnabled(false);
            Toast.makeText(this, "Bluetooth not enabled, closing app...", Toast.LENGTH_SHORT).show();
            // TODO: Catch exceptions if bluetooth is not available on device.
        }
    }
}

public void startClient() {
    try {
        BluetoothDevice bluetoothDevice = mBluetoothAdapter.getRemoteDevice(MAC_ADDRESS);
        mBluetoothGatt = bluetoothDevice.connectGatt(this, false, mGattCallback);

        if (mBluetoothGatt == null) {
            Log.w(TAG, "Unable to create GATT client");
            Toast.makeText(this, "Cant connect to " + MAC_ADDRESS, Toast.LENGTH_SHORT).show();
            return;
        }
    }
    catch (Exception e) {
        Log.w(TAG, e.toString());
    }
}

public static final String MAC_ADDRESS = "CA:A5:4F:3A:A9:5C";
public static final UUID UUID_SERVICE = UUID.fromString("0000fe84-0000-1000-8000-00805f9b34fb");
public static final UUID UUID_CHARACTERISTIC_BUTTONSTATUS = UUID.fromString("2d30c082-f39f-4ce6-923f-3484ea480596");

public static final UUID UUID_CHARACTERISTIC_LED = UUID.fromString("2d30c083-f39f-4ce6-923f-3484ea480596");

// This is one of the most used descriptor: Client Characteristic Configuration Descriptor. 0x2902
public static final UUID UUID_DESCRIPTOR = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");

private BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {

    private final String TAG = "mGattCallback";

    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {

        super.onConnectionStateChange(gatt, status, newState);
        Log.i(TAG, status + " " + newState);
        if (newState == BluetoothProfile.STATE_CONNECTED)
        {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    connectBtn.setEnabled(false);
                    disconectBtn.setEnabled(true);
                }
            });
            mBluetoothGatt.discoverServices();
        } else if (newState == BluetoothProfile.STATE_DISCONNECTED)
        {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    connectBtn.setEnabled(true);
                    disconectBtn.setEnabled(false);
                }
            });
        }
    }


    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        //Log.i(TAG, "Service discovered");

        if (status == gatt.GATT_SUCCESS) {
            BluetoothGattService service = gatt.getService(UUID_SERVICE);
            if (service != null) {
                Log.i(TAG, "Service connected");
                BluetoothGattCharacteristic characteristic = service.getCharacteristic(UUID_CHARACTERISTIC_BUTTONSTATUS);
                if (characteristic != null) {
                    Log.i(TAG, "Characteristic connected");
                    gatt.setCharacteristicNotification(characteristic, true);
                    BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID_DESCRIPTOR);
                    if (descriptor != null) {
                        // Los descriptors son muy importntes
                        // TODO: Continue studying about descriptors in BLE
                        descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                        gatt.writeDescriptor(descriptor);
                        Log.i(TAG, "Descriptor sended");
                    }
                }

                BluetoothGattCharacteristic characteristicLed = service.getCharacteristic(UUID_CHARACTERISTIC_LED);
                if (characteristicLed != null) {

                    Runnable myRunnable = new Runnable() {
                        @Override
                        public void run() {
                            if (isAlarmFired) {
                                writeLedCharacteristic(true);
                            }
                        }
                    };
                    Handler mainHandler = new Handler(Looper.getMainLooper());
                    mainHandler.postDelayed(myRunnable, 1000); // This causes myRunnable executed after 1000 ms, this is necesary for work, in this case we dont use runOnUiThread() because we are not modifying ui components.

                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if (isAlarmFired) {
                                btnOff.setEnabled(true);
                            }
                        }
                    });
                }
            }
        }
    }
/*
    @Override
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicRead(gatt, characteristic, status);
    }*/

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        readBtnStateCharacteristic(characteristic);
    }

    private void readBtnStateCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (UUID_CHARACTERISTIC_BUTTONSTATUS.equals(characteristic.getUuid())) {
            byte[] data = characteristic.getValue();
            //int state = Ints.fromByteArray(data);
            Log.i(TAG, data[0] + "");
            if (data[0] == 1) {

                Runnable r = new Runnable() {
                    @Override
                    public void run() {
                        WakeLocker.release();
                    }
                };

                Handler mainHandler = new Handler(Looper.getMainLooper());
                mainHandler.postDelayed(r, 2000);
                
                // In android callbacks are executed in another thread diferent to main thread, because of that, we should execute ui operations whitin a runnable in runOnUiThread method.
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        btnOff.setEnabled(false);
                        statusBtn.setText("Button Down");
                    }
                });
            } else if (data[0] == 0) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        statusBtn.setText("Button Up");
                    }
                });
            }
        }
    }
};

public void showTimePickerDialog(View view) {
    DialogFragment fragment = new SelectTimeFragment();
    fragment.show(getSupportFragmentManager(), "TimePicker");
}

public class SelectTimeFragment extends DialogFragment implements TimePickerDialog.OnTimeSetListener {
    private OnFragmentInteractionListener mListener;

    public SelectTimeFragment() {
        // Required empty public constructor
    }
    
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }


    @Override
    public Dialog onCreateDialog(Bundle savedInstance) {
        Calendar c = Calendar.getInstance();
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        
        // Por defecto al abrirse esta en la hora actual.
        return new TimePickerDialog(getActivity(), this, hour, minute, true);
    }

    // Called when user set a time
    @Override
    public void onTimeSet(TimePicker view, int hourOfDay, int minuteOfDay) {
        if (mListener != null) {
            // Toast.makeText(getActivity(), "Time seted", Toast.LENGTH_LONG).show();
            mListener.onPickerTimeSet(hourOfDay, minuteOfDay);
        }
    }


    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof OnFragmentInteractionListener) {
            mListener = (OnFragmentInteractionListener) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement OnFragmentInteractionListener");
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        mListener = null;
    }

    /**
     * This interface must be implemented by activities that contain this
     * fragment to allow an interaction in this fragment to be communicated
     * to the activity and potentially other fragments contained in that
     * activity.
     * <p>
     * See the Android Training lesson <a href=
     * "http://developer.android.com/training/basics/fragments/communicating.html"
     * >Communicating with Other Fragments</a> for more information.
     */
    public interface OnFragmentInteractionListener {
        void onPickerTimeSet(int hour, int minuts);
    }
}

public class MainActivity extends AppCompatActivity  implements
        SelectTimeFragment.OnFragmentInteractionListener {
    
    // class code here
    // ...
    
    // Code to execute when user select a time from the TimePicker dialog box.
    public void onPickerTimeSet(int hour, int minuts) {
        isTimeSeted = true;
        if (isTimeSeted) {
            canSetAlarm = true;
        }

        // Se activa el boton set alarm.
        btnSetAlarm.setEnabled(canSetAlarm);

        // Se hace un formato manual de la fecha para que las horas/minutos menores a 10 aparezcan con un 0 antes.
        String strhour = hour+"";
        String strminute = minuts+"";

        if (hour < 9) {
            strhour = "0" + hour;
        }
        if (minuts < 9) {
            strminute = "0" + minuts;
        }

        // Guarda la hora y el minuto de la alarma en un field tipo Calendar que sera usado para pasarlo como argumento al AlarmManager para disparar la alarma posteriormente.
        alarmOnDate.set(Calendar.HOUR_OF_DAY, hour);
        alarmOnDate.set(Calendar.MINUTE, minuts);
        textClock.setText("");
        
        textClock.setText(strhour + ":" + strminute);
    }
    
}

public class MainActivity extends AppCompatActivity  implements
        SelectDateFragment.OnFragmentInteractionListener {
    
    // class code here
    // ...
    
    // Code to execute when user select a time from the TimePicker dialog box.
    public void onPickerDateSet(Calendar c) {
        // The date is optional, in case when user doesnt specify one, today date is used.
        isDateSeted = true;
        if (isTimeSeted) {
            canSetAlarm = true;
        }
        btnSetAlarm.setEnabled(canSetAlarm);
        
        // Saves in the field alarmOnDate the yar, month and day to shoot the alarm.
        // this field will be used later on the AlarmManager for shoot the alarm.
        alarmOnDate.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DATE));
        
        // Show in the user interface the date picked.
        textDate.setText(c.get(Calendar.DATE) + "/" + (c.get(Calendar.MONTH)+1) + "/" + c.get(Calendar.YEAR));
    }
    
}

public void setAlarm(View view) {
    // When user clicks setAlarmButton, button get disabled inmediatelly.
    btnSetAlarm.setEnabled(false);

    // AlarmReceiver is an Android Broadcast Receiver that will have called if alarm get fired. 
    Intent intent = new Intent(this, AlarmReceiver.class);

    // If users has not specified the date of the alarm, app will use today date, so alarm date is optional
    if (!isDateSeted) {
        Calendar c = Calendar.getInstance(Locale.getDefault());
        alarmOnDate.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DATE));
    }

    // Creating a pending intent to be called when alarm get fired.
    PendingIntent pendingIntent = PendingIntent.getBroadcast(this, REQUEST_SET_ALARM, intent, PendingIntent.FLAG_CANCEL_CURRENT);
    
    // Passing the pending intent to AlarmManager for get fired when actualTimeInMillis - alarmOnDate.getTimeInMilles() <= 0
    alarmManager.set(AlarmManager.RTC_WAKEUP, alarmOnDate.getTimeInMillis(), pendingIntent);

}

public class AlarmReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.

        // This line ensures CPU is running as long as WakeLocker.release() dont get called.
        WakeLocker.acquire(context.getApplicationContext());
        
        // An intent for open the MainActivity from the BroadcastReceiver
        Intent i = new Intent(context.getApplicationContext(), MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        // This extra later will have used for know if the activity was opened from Alarm manager or not.
        i.putExtra(MainActivity.EXTRA_IS_FROM_ALARM, true);
        
        // Start the activity specified in the intent i
        context.startActivity(i);

    }
}