package nextrek.services;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;

public abstract class ClientConnector {

    public final static int MSG_WORK_FAILED = 1;
    public final static int MSG_WORK_SUCCEEDED = 2;
    public final static int MSG_WORK_PROGRESS = 3;
    
    final private Context mClientContext;
    final private Class<?> mServiceClass;

    public ClientConnector(Context clientContext, Class<?> serviceClass) {
        mClientContext = clientContext;
        mServiceClass = serviceClass;
    }

    /*
     * SERVICE BINDING
     */
    /** Messenger for communicating with service. */
    Messenger mService = null;
    /** Flag indicating whether we have called bind on the service. */
    boolean mIsBound;

    /**
     * Handler of incoming messages from service.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            
            switch (msg.what) {
                case ClientConnector.MSG_WORK_FAILED:
                case ClientConnector.MSG_WORK_SUCCEEDED:
                case ClientConnector.MSG_WORK_PROGRESS:
                    Bundle bundle = (Bundle)msg.obj;
                    onHandleResponse(msg.what, bundle);
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final IncomingHandler mIncomingHandler = new IncomingHandler();
    final Messenger mMessenger = new Messenger(mIncomingHandler);

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the service object we can use to
            // interact with the service. We are communicating with our
            // service through an IDL interface, so get a client-side
            // representation of that from the raw service object.
            mService = new Messenger(service);
            //mCallbackText.setText("Attached.");

            // We want to monitor the service for as long as we are
            // connected to it.
            try {
                Message msg = Message.obtain(null, ServiceConnector.MSG_REGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mService.send(msg);
                /*
                 * // Give it some value as an example.
                 * msg = Message.obtain(null, UploadService.MSG_SET_VALUE, this.hashCode(), 0);
                 * mService.send(msg);
                 */
            } catch (RemoteException e) {
                // In this case the service has crashed before we could even
                // do anything with it; we can count on soon being
                // disconnected (and then reconnected if it can be restarted)
                // so there is no need to do anything here.
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            //mCallbackText.setText("Disconnected.");
        }
    };

    // Establish a connection with the service. We use an explicit
    // class name because there is no reason to be able to let other
    // applications replace our component.
    public void BindService() {
        mClientContext.bindService(new Intent(mClientContext, mServiceClass), mConnection, Context.BIND_NOT_FOREGROUND | Context.BIND_AUTO_CREATE);
        mIsBound = true;
        //mCallbackText.setText("Binding.");
    }

    public void UnbindService() {
        if (mIsBound) {
            // If we have received the service, and hence registered with
            // it, then now is the time to unregister.
            if (mService != null) {
                try {
                    Message msg = Message.obtain(null, ServiceConnector.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                } catch (RemoteException e) {
                    // There is nothing special we need to do if the service
                    // has crashed.
                }
            }

            // Detach our existing connection.
            mClientContext.unbindService(mConnection);
            mIsBound = false;
            //mCallbackText.setText("Unbinding.");
        }
    }

    public void sendMessage(Bundle bundle) {
        if (mIsBound)
        {
            try {
                Message msg = Message.obtain(null, ServiceConnector.MSG_SEND, bundle);
                msg.replyTo = mMessenger;
                mService.send(msg);
            } catch (RemoteException e) {
                // In this case the service has crashed before we could even
                // do anything with it; we can count on soon being
                // disconnected (and then reconnected if it can be restarted)
                // so there is no need to do anything here.
            }
        }
        else
        {
            //throws RemoteException
        }
    }

    
    public abstract void onHandleResponse(int result, Bundle bundle);
}