package com.example.bandoo.opportunisticbledemo;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.le.AdvertiseCallback;
import android.bluetooth.le.AdvertiseData;
import android.bluetooth.le.AdvertiseSettings;
import android.bluetooth.le.BluetoothLeAdvertiser;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanRecord;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    // Appcontext
    Context ctx = null;

    // Logging
    private String logString = "";
    private TextView logView;

    private void initLog() {
        logView = (TextView)findViewById(R.id.AppLog);
        log("Actvity Created");
    }
    private void log(String str) {
        logString += str + "\n";
        logView.setText(logString);
    }

    // BT specific stuff
    protected Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
    private static final int REQUEST_ENABLE_BT = 1;
    private BluetoothAdapter mBluetoothAdapter = null;

    // Activity life-cycle
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ctx = getApplicationContext();

        initLog();

        // Use this check to determine whether BLE is supported on the device. Then
        // you can selectively disable BLE-related features.
        if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
            Toast.makeText(this, "BLE is not supported on this device", Toast.LENGTH_LONG).show();
            finish();
        } else {
            log("BLE hardware available");
        }

        // Initializes Bluetooth adapter.
        final BluetoothManager bluetoothManager =
                (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);

        mBluetoothAdapter = bluetoothManager.getAdapter();

        // 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()) {
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
        } else {
            startDemo();
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // Check which request we're responding to
        if (requestCode == REQUEST_ENABLE_BT) {
            // Make sure the request was successful
            if (resultCode == RESULT_OK) {
                startDemo();
            } else {
                Toast.makeText(this, "Bluetooth must be turned on for this demo", Toast.LENGTH_LONG).show();
                finish();
            }
        }
    }

    @Override
    protected void onDestroy() {
        // PART II.
        mHandler.removeCallbacksAndMessages(null);
        if (mScanner != null) {
            enableScanning(false);
        }
        // Part IV.
        if (mAdvertiser != null) {
            enableAdvertising(false);
        }
        if (mBluetoothAdapter.isEnabled()) {
            mBluetoothAdapter.disable();
        }
        super.onDestroy();
    }

    // Demo specific functions
    private void startDemo() {
        log("BLE adapter enabled\n - MAC_ADDR: " + mBluetoothAdapter.getAddress());

        //Part II.
        mHandler = new Handler();
        mScanner = mBluetoothAdapter.getBluetoothLeScanner();
        mScanParams = new ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build();
        enableScanning(true);

        // Part III. meg kell írni !
        //updateNeptunCodesToForward("VALAKI");

        byte forward_test[] = new byte[] {0,0,0,0,0,0,8,78,8,8,22,1,2,3,4,5,6,7,8,9,8,7,6,5};
        updateData(forward_test);
        //showStats();

        // Part IV.
        mAdvertiser = mBluetoothAdapter.getBluetoothLeAdvertiser();
        mAdvParams = new AdvertiseSettings.Builder().setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY).build();
        enableAdvertising(true);
    }

    //Part II.

    private Handler mHandler;

    protected BluetoothLeScanner mScanner = null;
    private ScanSettings mScanParams;
    private int scanError = 0;
    // Stops scanning after 10 seconds.
    private static final long SCAN_PERIOD = 10000;

    // Device scan callback.
    private ScanCallback mScanCallback = new ScanCallback() {
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            super.onScanResult(callbackType, result);
            BluetoothDevice device = result.getDevice();
            log("New Device Found: "+device.getAddress());
            processAllData(result.getScanRecord());
        }

        @Override
        public void onBatchScanResults(List<ScanResult> results) {
            super.onBatchScanResults(results);
            for (int i = 0; i < results.size(); i++) {
                BluetoothDevice device = results.get(i).getDevice();
                log("New Device Found: "+device.getAddress());
                processAllData(results.get(i).getScanRecord());
            }
        }

        @Override
        public void onScanFailed(int errorCode) {
            super.onScanFailed(errorCode);
            scanError = errorCode;
        }
    };

    private void enableScanning(final boolean enable) {
        if (enable) {
            if ( scanError == 0) {
                // Stops scanning after a pre-defined scan period.
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mScanner.stopScan(mScanCallback);
                        log("Scanning Stopped");
                        enableScanning(true);
                    }
                }, SCAN_PERIOD);
                mScanner.startScan(new ArrayList<ScanFilter>(), mScanParams, mScanCallback);
            } else {
                Toast.makeText(this, "Scanning Failed - errorCode="+scanError, Toast.LENGTH_LONG).show();
            }
            log("Scanning Started");
        } else {
            mScanner.stopScan(mScanCallback);
            log("Scanning Stopped");
        }

    }

    // Part III.
    // Demo app specific datasets


    //teszt
    // private ArrayList<String> NeptunCodes = new ArrayList<String>();
    //mine
    private byte[] AllData = new byte[24];

    private void showStats() {
        //String statString = "Neptun\n";
       /* for (int i = 0; i < NeptunCodes.size(); i++) {
            statString += NeptunCodes.get(i);
        }
        logView.setText(statString);*/
        String write_out= Arrays.toString(AllData);

        logView.setText(write_out);

    }

    /* private void updateNeptunCodesToForward(String NeptunCode) {
         NeptunCodes.add(NeptunCode);
         showStats();
     }
 */
    private void updateData(byte[] Data)
    {

        for (int i = 0; i<23; i++)
        {

            AllData[i]=Data[i];
        }
        showStats();

    }


    // Manufacturer Id.
    private static final int MANUFACTURER_ID = 0x01DC; // iParking Ltd.

    // BLE-specific functions
   /* private void processScanData(ScanRecord record) {
        byte mData[] = record.getManufacturerSpecificData(MANUFACTURER_ID);
        if ( mData == null) {
            // No MSData for us
        }
        else {
            String neptunCode = "";
            for (int i = 0; i < 6; i++) {
                neptunCode+=(char)mData[i];
            }
            updateNeptunCodesToForward(neptunCode);
            //showStats();
        }
    }
*/
    private void processAllData(ScanRecord record)
    {
        byte mData[] = record.getManufacturerSpecificData(MANUFACTURER_ID);
        if ( mData == null) {
            // No MSData for us

        }
        else
        {
            for(int i = 0; i<23; i++)
            {
                AllData[i] = mData[i];

            }
        }
    }



    // Part IV.

    // private String currentNeptunCode= "Valami";


    // ezt kell átírni
   /* private String getNextNeptunCodeToForward() {


        return currentNeptunCode;

    }
*/
    private byte[] currentData = new byte[24];

    protected BluetoothLeAdvertiser mAdvertiser = null;
    private AdvertiseSettings mAdvParams;
    private int advError = 0;
    // Restarts advertising after 0,5 seconds
    private static final long ADV_PERIOD = 500;
    // Periodic start of advertising could freeze the stack
    private static final long RESTART_AFTER_ADV_COUNT = 1000;
    private int advCount = 0;



    /* private AdvertiseData getNextAdvertisingData() {
         currentNeptunCode = getNextNeptunCodeToForward();
         byte msData[] = new byte[6]; // Neptun Code
         for (int i = 0; i < 6; i++) {
             msData[i] = (byte)currentNeptunCode.charAt(i);
         }
         return new AdvertiseData.Builder().addManufacturerData(MANUFACTURER_ID, msData).build();
     }
 */
    private AdvertiseData getNextAdvData()
    {

        byte msData[] = new byte[24];
        for (int i = 0; i < 23; i++) {

            msData[i] = AllData[i];
        }
        return new AdvertiseData.Builder().addManufacturerData(MANUFACTURER_ID, msData).build();

    }


    // Advertising Callback
    private AdvertiseCallback mAdvertiseCallback = new AdvertiseCallback() {
        @Override
        public void onStartSuccess(AdvertiseSettings settingsInEffect) {
            super.onStartSuccess(settingsInEffect);
            advCount++;
            if ( advCount == RESTART_AFTER_ADV_COUNT ) {
                advCount = 0;
                mScanner.stopScan(mScanCallback);
                mAdvertiser.stopAdvertising(mAdvertiseCallback);
                mHandler.removeCallbacksAndMessages(null);
                mBluetoothAdapter.disable();
                mAdvertiser = null;
                mScanner = null;
                startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
            } else {
                // Restarts advertising after a pre-defined advertising period.
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mAdvertiser.stopAdvertising(mAdvertiseCallback);
                        // updateNeptunCodesToForward(currentNeptunCode);
                        updateData(AllData);
                        enableAdvertising(true);
                    }
                }, ADV_PERIOD);
            }
        }

        @Override
        public void onStartFailure(int errorCode) {
            super.onStartFailure(errorCode);
            advError = errorCode;
            Toast.makeText(ctx, "Advertising Failed - errorCode="+advError, Toast.LENGTH_LONG).show();
        }
    };

    private void enableAdvertising(final boolean enable) {
        if (enable) {
            mAdvertiser.startAdvertising(mAdvParams, getNextAdvData(), mAdvertiseCallback);
        } else {
            mAdvertiser.stopAdvertising(mAdvertiseCallback);
        }

    }


}