package com.moonlightcheese.btsrv;

import java.lang.*;
import java.io.*;
import java.util.*;

import android.app.*;
import android.os.*;
import android.bluetooth.*;
import android.content.*;
import android.util.Log;

//service that dies when completely unbound
public class ScannerService extends Service
{
    //instance of the Binder we define in this Service
    private final IBinder mBinder = new ScannerBinder();

    //local variable needed for bluetooth connectivity
    BluetoothAdapter btAdapter;         //the local Bluetooth adapter
    BluetoothDevice mScanner;           //the scanner we are connecting to
    boolean isDiscoveringLocal = false; //a boolean value that we set/unset to tell if this service initiated discovery, this avoids listing devices if another application initiated the discovery
    List<BluetoothDevice> scannerList;  //the list of bluetooth scanners found during discovery
    public static final UUID BLUETOOTH_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");      //the UUID.  magic.
    ReconnectThread mRCT;
    BluetoothConnectThread mBCT;
    SharedPreferences mPrefs;

    //message ids and constants
    public final static int MESSAGE_BT_READ = 21;
    public final static int MESSAGE_SOCKET_ERROR = 22;
    public final static int REQUEST_ENABLE_BT = 10;
    public final static String ACTION_SELECT_SCANNER = "com.conceptualsystems.scannerservice.selectscanner";
    public final static String ACTION_READ_SCANNER = "com.conceptualsystems.scannerservice.readscanner";
    public final static String ACTION_REQUEST_RECONNECT = "com.conceptualsystems.scannerservice.request_reconnect";
    public final static String ACTION_RECONNECT = "com.conceptualsystems.scannerservice.reconnect";
    public final static String LOG_TAG = "btsrv - ScannerService.java";

    // Class that extends Binder
    ////////////////////////////
    public class ScannerBinder extends Binder {
        ScannerService getService () {
            //return this instance
            return ScannerService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    @Override
    public void onCreate()
    {
        super.onCreate();

        scannerList = new ArrayList<BluetoothDevice>();
        mPrefs = getSharedPreferences("conceptualbluetoothscannerpreferences", Context.MODE_PRIVATE);

        // Register the BroadcastReceiver
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothDevice.ACTION_FOUND);
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED);
        filter.addAction(ScannerService.ACTION_RECONNECT);
        //TODO: unregister receiver onDestroy()
        registerReceiver(mReceiver, filter);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if(mRCT!=null && mRCT.mReconnecting) {
            Log.i(LOG_TAG, "attempting reconnect...");
            mRCT.interrupt();
        }
        Log.i(LOG_TAG, "onDestroy called in ScannerService");
        unregisterReceiver(mReceiver);
        if(mBCT!=null) {
            Log.i(LOG_TAG, "killing mBCT");
            //mBCT.cancel();
        }
    }

    private class ReconnectThread extends Thread {
        //Members
        BluetoothDevice mDevice;
        public boolean mReconnecting;

        //Constructor
        public ReconnectThread(BluetoothDevice device) {
            this.mDevice=device;
            this.mReconnecting=true;
        }

        public void reconnect() {
            try {
                this.mReconnecting=true;
                mBCT = new BluetoothConnectThread(mScanner, btHandler);
                mBCT.start();
            } catch(Exception e) {
                if(mScanner==null) {
                    Log.i(LOG_TAG, "mScanner: error in RCT: "+e.getMessage());
                }
                if(btHandler==null) {
                    Log.i(LOG_TAG, "btHandler: error in RCT: "+e.getMessage());
                }
                if(mBCT==null) {
                    Log.i(LOG_TAG, "mBCT: error in RCT: "+e.getMessage());
                }
            }

        }

        public void run() {
            //try to reconnect one time
            this.reconnect();
            //loop until an interrupt has been received
            while(true) {
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException e) {
                    this.mReconnecting=false;
                    return;
                }
            }
        }
    }

    // Create a BroadcastReceiver for ACTION_FOUND, ACTION_STATE_CHANGED, ACTION_DISCOVERY_FINISHED
    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (BluetoothDevice.ACTION_FOUND.equals(action) && isDiscoveringLocal) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                boolean newEntry = true;
                Log.i(LOG_TAG, "found device: "+device.getName());
                for(BluetoothDevice storedDevice : scannerList) {
                    if(device.getAddress().equals(storedDevice.getAddress())) {
                        newEntry = false;
                    }
                }
                if(newEntry) {
                    scannerList.add(device);
                }
            }
            if(BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
                isDiscoveringLocal = false;
                Log.i(LOG_TAG, "discovery finished.");
                //TODO: broadcast an intent to interested applications so they can choose the device to use
                if(!scannerList.isEmpty()) {
                    Intent i = new Intent(ACTION_SELECT_SCANNER);
                    List<String> scannerLabels = new ArrayList<String>(scannerList.size());
                    for(BluetoothDevice device : scannerList) {
                        scannerLabels.add(device.getName()+"\n"+device.getBluetoothClass().toString());
                    }
                    i.putExtra("scannerArray", scannerLabels.toArray(new String[1]));
                    sendBroadcast(i);
                    Log.i(LOG_TAG, "sent broadcast with array elements: " + scannerList.toString());
                    Log.i(LOG_TAG, "size of scannerList: " + scannerList.size());
                    Log.i(LOG_TAG, "size of scannerLabels: " + scannerLabels.size());
                } else {
                    Intent i = new Intent(ACTION_SELECT_SCANNER);
                    sendBroadcast(i);
                    Log.i(LOG_TAG, "sent broadcast with empty intent (no extras)");
                }
            }
            if(BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
                if(BluetoothAdapter.STATE_ON == btAdapter.getState()) {
                    //initialize();     //make a call to initialize when the adapter turns on to perform the discovery process
                }
            }
            ////////////////////////////
            //TODO: may need to rebond sometimes.  initiate rebonding if device becomes unpaired here.
            if(BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
                int bondState = -1;
                int oldBondState = -1;
                BluetoothDevice device = null;
                try {
                    bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.BOND_NONE);
                    oldBondState = intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE, BluetoothDevice.BOND_NONE);
                    device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                } catch (Exception e) {
                    //
                }
                Log.i(LOG_TAG, "bond state changed.");
                Log.i(LOG_TAG, "device name: "+device.getName());
                Log.i(LOG_TAG, "device addr: "+device.getAddress());
                switch(bondState) {
                    case BluetoothDevice.BOND_NONE:
                        Log.i(LOG_TAG, "now unbonded");
                        break;
                    case BluetoothDevice.BOND_BONDED:
                        Log.i(LOG_TAG, "now bonded");
                        break;
                    case BluetoothDevice.BOND_BONDING:
                        Log.i(LOG_TAG, "now bonding");
                        break;
                }
                switch(oldBondState) {
                    case BluetoothDevice.BOND_NONE:
                        Log.i(LOG_TAG, "was unbonded");
                        break;
                    case BluetoothDevice.BOND_BONDED:
                        Log.i(LOG_TAG, "was bonded");
                        break;
                    case BluetoothDevice.BOND_BONDING:
                        Log.i(LOG_TAG, "was bonding");
                        break;
                }
            }
            if(BluetoothDevice.ACTION_ACL_CONNECTED.equals(action)) {
                Log.i(LOG_TAG, "connected.");
                if(mScanner!=null) {
                    SharedPreferences myPrefs = context.getSharedPreferences("conceptualbluetoothscannerpreferences", Context.MODE_PRIVATE);
                    SharedPreferences.Editor editor = myPrefs.edit();
                    editor.putString("lastscanner", mScanner.getAddress());
                    editor.commit();
                }
                if(mRCT!=null && mRCT.mReconnecting) {
                    mRCT.interrupt();
                }
            }
            if(BluetoothDevice.ACTION_ACL_DISCONNECTED.equals(action)) {
                Log.i(LOG_TAG, "disconnected.");
                //TODO: check the pref stored device in addition to the local, last used device in memory
                Intent reconnectIntent = new Intent();
                reconnectIntent.setAction(ScannerService.ACTION_REQUEST_RECONNECT);
                sendBroadcast(reconnectIntent);
            }
            if(BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED.equals(action)) {
                Log.i(LOG_TAG, "disconnect requested.");
            }
            if(ScannerService.ACTION_RECONNECT.equals(action)) {
                if(mScanner!=null) {
                    mRCT = new ReconnectThread(mScanner);
                    mRCT.start();
                }
            }
        }
    };

    public void selectBluetoothDevice(int selection) {
        //
        if(scannerList.isEmpty()) {
            //TODO: NullPointerException needs to go here
            Log.i(LOG_TAG, "NullPointerException?");
        } else {
            if(selection > scannerList.size()-1 || selection < 0) {
                //TODO: IllegalArgumentException needs to go here
                Log.i(LOG_TAG, "IllegalArgumentException");
            } else {
                //argument should be good, use this selection to select the BluetoothDevice to connect to
                mScanner = scannerList.get(selection);
                scannerList.clear(); //clear the list after selection
                mBCT = new BluetoothConnectThread(mScanner, btHandler);
                mBCT.start();
            }
        }
    }

    public void startBluetoothDiscovery() {
        isDiscoveringLocal = true;
        Log.i(LOG_TAG, "starting discovery process...");
        btAdapter.startDiscovery();
    }

    public void connectLastScanner() {
        String scannerAddress = mPrefs.getString("lastscanner", null);
        if(scannerAddress!=null) {
            mScanner = btAdapter.getRemoteDevice(scannerAddress);
            Log.i(LOG_TAG, "connecting to last known scanner: "+mScanner.getAddress());
            mBCT = new BluetoothConnectThread(mScanner, btHandler);
            mBCT.start();
        }
    }

    public boolean initialize() {
        btAdapter = BluetoothAdapter.getDefaultAdapter();
        if(btAdapter == null) {
            //no bluetooth adapter available.  do not run bluetooth code.
            return false;
        } else {
            if(!btAdapter.isEnabled()) {  //enable bluetooth if disabled.
                btAdapter.enable();
                scannerList.clear();
            } else {
                scannerList.clear();
            }
        }
        while(!btAdapter.isEnabled());
        return true;
    }

    public boolean disable() {
        btAdapter = BluetoothAdapter.getDefaultAdapter();
        if(btAdapter!=null) {
            btAdapter.disable();
            mScanner = null;
            scannerList.clear();
        } else {
            return false;
        }
        return true;
    }

    public boolean isBonded(BluetoothDevice device) {
        if(device.getBondState()==BluetoothDevice.BOND_NONE) {
            return false;
        }

        return true;
    }
    /*
    public boolean doBond(BluetoothDevice device) {
        Intent intent = new Intent(BluetoothDevice.ACTION_PAIRING_REQUEST);
        intent.putExtra(EXTRA_DEVICE, device);
        int PAIRING_VARIANT_PIN = 272;
        intent.putExtra(BluetoothDevice.EXTRA_PAIRING_VARIANT, PAIRING_VARIANT_PIN);
        sendBroadcast(intent);
    }
    */
    private class BluetoothServerThread extends Thread {
        private BluetoothServerSocket btServerSocket;

        public BluetoothServerThread() {
            BluetoothServerSocket tmp = null;
            try {
                tmp = btAdapter.listenUsingRfcommWithServiceRecord("smsmobile", BLUETOOTH_UUID);
            } catch (IOException e) {}
            btServerSocket = tmp;
        }

        public void run() {
            BluetoothSocket socket = null;
            while(true) {
                try {
                    socket = btServerSocket.accept();
                } catch (IOException e) {
                    break;
                }
                if(socket != null) {
                    BluetoothSocketThread socketThread = new BluetoothSocketThread(socket, btHandler);
                    socketThread.start();
                    try {
                        btServerSocket.close();
                    } catch (IOException e) {
                        Log.e(LOG_TAG+":bst", "could not close the server socket?  i mean srsly, wtf?");
                    }
                    break;
                }
            }
        }

        public void cancel() {
            try {
                btServerSocket.close();
            } catch (IOException e) {}
        }
    };

    private class BluetoothConnectThread extends Thread {
        private BluetoothSocket mSocket;
        private BluetoothDevice mDevice;
        private Handler mHandler;
        private BluetoothSocketThread mBST;

        public BluetoothConnectThread(BluetoothDevice device, Handler handler) {
            BluetoothSocket tmp = null;
            mDevice = device;
            mHandler = handler;

            try {
                tmp = device.createRfcommSocketToServiceRecord(BLUETOOTH_UUID);
            } catch (IOException e) {
                Log.e(LOG_TAG, "could not create rfcomm socket as client");
            }

            mSocket = tmp;
        }

        public synchronized void run() {
            btAdapter.cancelDiscovery();
            try {
                mSocket.connect();
                mBST = new BluetoothSocketThread(mSocket, btHandler);
                mBST.start();
            } catch (Exception e) {
                if(mSocket == null) {
                    Log.e(LOG_TAG, "device socket was never initiated, socket is null");
                }
                Log.e(LOG_TAG, "connection failed");
                Log.e(LOG_TAG, e.toString());
                Message m = Message.obtain(mHandler, MESSAGE_SOCKET_ERROR);
                mHandler.sendMessage(m);
            }
        }

        public void cancel() {
            mBST.cancel();
        }
    };

    private class BluetoothSocketThread extends Thread {
        private BluetoothSocket mSocket;
        private LineNumberReader mInStream;
        private OutputStream mOutStream;
        private Handler mHandler;

        public BluetoothSocketThread(BluetoothSocket socket, Handler handler) {
            mSocket = socket;
            LineNumberReader tmpIn = null;
            OutputStream tmpOut = null;
            mHandler = handler;

            try {
                tmpIn = new LineNumberReader(new InputStreamReader(socket.getInputStream()));
                tmpOut = socket.getOutputStream();
            } catch(IOException e) {
                Log.e(LOG_TAG, "could not capture input/output stream");
                //Message m = Message.obtain(mHandler, MESSAGE_SOCKET_ERROR);
                //mHandler.sendMessage(m);
            }

            mInStream = tmpIn;
            mOutStream = tmpOut;
        }

        public void run() {
            //Message m = Message.obtain(mHandler, MESSAGE_SOCKET_SEND, mSocket);
            //mHandler.sendMessage(m);
            Log.i(LOG_TAG, "socket successfully connected... starting listener loop");
            while(true) {
                try {
                    String curScan = mInStream.readLine();
                    Log.i(LOG_TAG, "scan read in service: "+curScan);
                    Message m = Message.obtain(mHandler, MESSAGE_BT_READ, curScan);
                    mHandler.sendMessage(m);
                } catch(IOException e) {
                    Log.e(LOG_TAG, "read or handling error, dropping connection");
                    this.cancel();
                    break;
                }
            }
        }

        public void write(byte[] bytes) {
            try {
                mOutStream.write(bytes);
            } catch (IOException e) {
                Log.e(LOG_TAG, "write error");
            }
        }

        public void cancel() {
            try {
                mInStream.close();
                mOutStream.close();
                mSocket.close();
                mInStream = null;
                mOutStream = null;
                mSocket = null;
            } catch(IOException e) {
                Log.i(LOG_TAG, "client connection wouldn't close");
            }
        }
    };

    private final Handler btHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what) {
                case MESSAGE_BT_READ:
                    //a read was requested
                    ////broadcast an intent containing the string read from the scanner
                    Intent i = new Intent(ACTION_READ_SCANNER);
                    i.putExtra("scannerRead", (String)msg.obj);
                    sendBroadcast(i);
                    //Log.i(LOG_TAG+":bth", "read a message" + (String)msg.obj);
                    break;
                case MESSAGE_SOCKET_ERROR:
                    //error.  if the reconnect thread is up and running, attempt a reconnect.
                    Log.e(LOG_TAG, "a socket error occurred when trying to connect");
                    if(mRCT!=null && mRCT.mReconnecting) {
                        Log.i(LOG_TAG, "attempting reconnect...");
                        mRCT.reconnect();
                    } else {
                        //this was a first attempt.  what do?
                        //first let's try to disconnect manually since the device may think it's connected to something.
                        if(mScanner!=null && !isBonded(mScanner)) {
                            //bond the scanner (pairing)
                            //doBond(mScanner);
                        } else {
                            Log.e(LOG_TAG, "big problem, we got a socket error and mScanner was null.  that should pretty much never happen.  ever.");
                        }
                    }
                    break;
            }
        }
    };
}