/*
 * Copyright (C) 2012 Google Inc.
 *
 * 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.googlecode.eyesfree.braille.selfbraille;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.Signature;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Client-side interface to the self brailling interface.
 *
 * Threading: Instances of this object should be created and shut down
 * in a thread with a {@link Looper} associated with it.  Other methods may
 * be called on any thread.
 */
public class SelfBrailleClient {
    private static final String LOG_TAG =
            SelfBrailleClient.class.getSimpleName();
    private static final String ACTION_SELF_BRAILLE_SERVICE =
            "com.googlecode.eyesfree.braille.service.ACTION_SELF_BRAILLE_SERVICE";
    private static final String BRAILLE_BACK_PACKAGE =
            "com.googlecode.eyesfree.brailleback";
    private static final Intent mServiceIntent =
            new Intent(ACTION_SELF_BRAILLE_SERVICE)
            .setPackage(BRAILLE_BACK_PACKAGE);
    /**
     * SHA-1 hash value of the Eyes-Free release key certificate, used to sign
     * BrailleBack.  It was generated from the keystore with:
     * $ keytool -exportcert -keystore <keystorefile> -alias android.keystore \
     *   > cert
     * $ keytool -printcert -file cert
     */
    // The typecasts are to silence a compiler warning about loss of precision
    private static final byte[] EYES_FREE_CERT_SHA1 = new byte[] {
        (byte) 0x9B, (byte) 0x42, (byte) 0x4C, (byte) 0x2D,
        (byte) 0x27, (byte) 0xAD, (byte) 0x51, (byte) 0xA4,
        (byte) 0x2A, (byte) 0x33, (byte) 0x7E, (byte) 0x0B,
        (byte) 0xB6, (byte) 0x99, (byte) 0x1C, (byte) 0x76,
        (byte) 0xEC, (byte) 0xA4, (byte) 0x44, (byte) 0x61
    };
    /**
     * Delay before the first rebind attempt on bind error or service
     * disconnect.
     */
    private static final int REBIND_DELAY_MILLIS = 500;
    private static final int MAX_REBIND_ATTEMPTS = 5;

    private final Binder mIdentity = new Binder();
    private final Context mContext;
    private final boolean mAllowDebugService;
    private final SelfBrailleHandler mHandler = new SelfBrailleHandler();
    private boolean mShutdown = false;

    /**
     * Written in handler thread, read in any thread calling methods on the
     * object.
     */
    private volatile Connection mConnection;
    /** Protected by synchronizing on mHandler. */
    private int mNumFailedBinds = 0;

    /**
     * Constructs an instance of this class.  {@code context} is used to bind
     * to the self braille service.  The current thread must have a Looper
     * associated with it.  If {@code allowDebugService} is true, this instance
     * will connect to a BrailleBack service without requiring it to be signed
     * by the release key used to sign BrailleBack.
     */
    public SelfBrailleClient(Context context, boolean allowDebugService) {
        mContext = context;
        mAllowDebugService = allowDebugService;
        doBindService();
    }

    /**
     * Shuts this instance down, deallocating any global resources it is using.
     * This method must be called on the same thread that created this object.
     */
    public void shutdown() {
        mShutdown = true;
        doUnbindService();
    }

    public void write(WriteData writeData) {
        writeData.validate();
        ISelfBrailleService localService = getSelfBrailleService();
        if (localService != null) {
            try {
                localService.write(mIdentity, writeData);
            } catch (RemoteException ex) {
                Log.e(LOG_TAG, "Self braille write failed", ex);
            }
        }
    }

    private void doBindService() {
        Connection localConnection = new Connection();
        if (!mContext.bindService(mServiceIntent, localConnection,
                Context.BIND_AUTO_CREATE)) {
            Log.e(LOG_TAG, "Failed to bind to service");
            mHandler.scheduleRebind();
            return;
        }
        mConnection = localConnection;
        Log.i(LOG_TAG, "Bound to self braille service");
    }

    private void doUnbindService() {
        if (mConnection != null) {
            ISelfBrailleService localService = getSelfBrailleService();
            if (localService != null) {
                try {
                    localService.disconnect(mIdentity);
                } catch (RemoteException ex) {
                    // Nothing to do.
                }
            }
            mContext.unbindService(mConnection);
            mConnection = null;
        }
    }

    private ISelfBrailleService getSelfBrailleService() {
        Connection localConnection = mConnection;
        if (localConnection != null) {
            return localConnection.mService;
        }
        return null;
    }

    private boolean verifyPackage() {
        PackageManager pm = mContext.getPackageManager();
        PackageInfo pi;
        try {
            pi = pm.getPackageInfo(BRAILLE_BACK_PACKAGE,
                    PackageManager.GET_SIGNATURES);
        } catch (PackageManager.NameNotFoundException ex) {
            Log.w(LOG_TAG, "Can't verify package " + BRAILLE_BACK_PACKAGE,
                    ex);
            return false;
        }
        MessageDigest digest;
        try {
            digest = MessageDigest.getInstance("SHA-1");
        } catch (NoSuchAlgorithmException ex) {
            Log.e(LOG_TAG, "SHA-1 not supported", ex);
            return false;
        }
        // Check if any of the certificates match our hash.
        for (Signature signature : pi.signatures) {
            digest.update(signature.toByteArray());
            if (MessageDigest.isEqual(EYES_FREE_CERT_SHA1, digest.digest())) {
                return true;
            }
            digest.reset();
        }
        if (mAllowDebugService) {
            Log.w(LOG_TAG, String.format(
                "*** %s connected to BrailleBack with invalid (debug?) "
                + "signature ***",
                mContext.getPackageName()));
            return true;
        }
        return false;
    }
    private class Connection implements ServiceConnection {
        // Read in application threads, written in main thread.
        private volatile ISelfBrailleService mService;

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder binder) {
            if (!verifyPackage()) {
                Log.w(LOG_TAG, String.format("Service certificate mismatch "
                                + "for %s, dropping connection",
                                BRAILLE_BACK_PACKAGE));
                mHandler.unbindService();
                return;
            }
            Log.i(LOG_TAG, "Connected to self braille service");
            mService = ISelfBrailleService.Stub.asInterface(binder);
            synchronized (mHandler) {
                mNumFailedBinds = 0;
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName className) {
            Log.e(LOG_TAG, "Disconnected from self braille service");
            mService = null;
            // Retry by rebinding.
            mHandler.scheduleRebind();
        }
    }

    private class SelfBrailleHandler extends Handler {
        private static final int MSG_REBIND_SERVICE = 1;
        private static final int MSG_UNBIND_SERVICE = 2;

        public void scheduleRebind() {
            synchronized (this) {
                if (mNumFailedBinds < MAX_REBIND_ATTEMPTS) {
                    int delay = REBIND_DELAY_MILLIS << mNumFailedBinds;
                    sendEmptyMessageDelayed(MSG_REBIND_SERVICE, delay);
                    ++mNumFailedBinds;
                }
            }
        }

        public void unbindService() {
            sendEmptyMessage(MSG_UNBIND_SERVICE);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REBIND_SERVICE:
                    handleRebindService();
                    break;
                case MSG_UNBIND_SERVICE:
                    handleUnbindService();
                    break;
            }
        }

        private void handleRebindService() {
            if (mShutdown) {
                return;
            }
            if (mConnection != null) {
                doUnbindService();
            }
            doBindService();
        }

        private void handleUnbindService() {
            doUnbindService();
        }
    }
}