// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package com.olio.server;

import android.content.ContentResolver;
import android.content.Context;
import android.content.Loader;
import android.content.UriMatcher;
import android.database.ContentObserver;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.SystemClock;
import com.olio.communication.messages.Message;
import com.olio.data.object.bluetooth_status.BluetoothStatus;
import com.olio.data.object.bluetooth_status.BluetoothStatusLoader;
import com.olio.util.ALog;
import com.olio.util.RecoveryTimer;
import java.util.Collection;
import java.util.Iterator;
import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import org.jdeferred.Deferred;
import org.jdeferred.DoneCallback;
import org.jdeferred.FailCallback;
import org.jdeferred.Promise;
import org.jdeferred.impl.DeferredObject;

public class RequestManager
{
    private class BluetoothOnLoadListener
        implements android.content.Loader.OnLoadCompleteListener
    {

        final RequestManager this$0;

        public void onLoadComplete(Loader loader, BluetoothStatus bluetoothstatus)
        {
            if (!bluetoothstatus.isConnected(contentResolver, com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.Platform.WATCH))
            {
                observerHandler.post(new Runnable() {

                    final BluetoothOnLoadListener this$1;

                    public void run()
                    {
                        Iterator iterator = callbackCache.values().iterator();
                        do
                        {
                            if (!iterator.hasNext())
                            {
                                break;
                            }
                            RequestManagerDeferred requestmanagerdeferred = (RequestManagerDeferred)iterator.next();
                            if (requestmanagerdeferred.isPending())
                            {
                                requestmanagerdeferred.handler.post(requestmanagerdeferred. new Runnable() {

                                    final BluetoothOnLoadListener._cls1 this$2;
                                    final RequestManagerDeferred val$deferred;

                                    public void run()
                                    {
                                        if (deferred.isPending())
                                        {
                                            deferred.reject(null);
                                        }
                                    }

            
            {
                this$2 = final__pcls1;
                deferred = RequestManagerDeferred.this;
                super();
            }
                                });
                            }
                        } while (true);
                        callbackCache.clear();
                    }

            
            {
                this$1 = BluetoothOnLoadListener.this;
                super();
            }
                });
            }
        }

        public volatile void onLoadComplete(Loader loader, Object obj)
        {
            onLoadComplete(loader, (BluetoothStatus)obj);
        }

        private BluetoothOnLoadListener()
        {
            this$0 = RequestManager.this;
            super();
        }

    }

    public static class RequestManagerDeferred extends DeferredObject
    {

        Handler handler;
        private Runnable timeOutRunnable;
        RecoveryTimer timer;

        public Deferred notify(RequestProgress requestprogress)
        {
            if (isPending())
            {
                return super.notify(requestprogress);
            } else
            {
                ALog.e("MessageRequestManager notify failed", new Object[0]);
                return this;
            }
        }

        public volatile Deferred notify(Object obj)
        {
            return notify((RequestProgress)obj);
        }

        public volatile Deferred reject(Object obj)
        {
            return reject((Void)obj);
        }

        public Deferred reject(Void void1)
        {
            timer.dispose();
            return super.reject(void1);
        }

        public volatile Deferred resolve(Object obj)
        {
            return resolve((Void)obj);
        }

        public Deferred resolve(Void void1)
        {
            timer.dispose();
            return super.resolve(void1);
        }

        public RequestManagerDeferred(Handler handler1, Context context)
        {
            timeOutRunnable = new _cls1();
            handler = handler1;
            timer = new RecoveryTimer(String.format(Locale.US, "com.olio.bluetoothancs.RequestManager.deferredCountdown-%s", new Object[] {
                Long.toString(SystemClock.elapsedRealtime())
            }), false);
            timer.init(context, handler1);
            timer.startOrRestart(TimeUnit.MINUTES.toMillis(15L), timeOutRunnable);
        }
    }

    private class RequestManagerObserver extends ContentObserver
    {

        UriMatcher matcher;
        final RequestManager this$0;

        public boolean deliverSelfNotifications()
        {
            return super.deliverSelfNotifications();
        }

        public void onChange(boolean flag, Uri uri)
        {
            super.onChange(flag, uri);
            com.olio.server.request.RequestsContract.RequestsContractRequest requestscontractrequest;
            if (matcher.match(uri) == 0)
            {
                if ((requestscontractrequest = com.olio.server.request.RequestsContract.RequestsContractRequest.requestFromUri(contentResolver, uri)) != null)
                {
                    int i = requestscontractrequest.getStatus();
                    long l = Long.valueOf(uri.getLastPathSegment()).longValue();
                    uri = (RequestManagerDeferred)callbackCache.remove(Long.valueOf(l));
                    if (uri != null)
                    {
                        switch (i)
                        {
                        default:
                            return;

                        case 0: // '\0'
                            ((RequestManagerDeferred) (uri)).handler.post(uri. new Runnable() {

                                final RequestManagerObserver this$1;
                                final RequestManagerDeferred val$deferred;

                                public void run()
                                {
                                    if (deferred.isPending())
                                    {
                                        deferred.reject(null);
                                        return;
                                    } else
                                    {
                                        ALog.d("MessageRequestManager: No deferred. Most likely already rejected", new Object[0]);
                                        return;
                                    }
                                }

            
            {
                this$1 = final_requestmanagerobserver;
                deferred = RequestManagerDeferred.this;
                super();
            }
                            });
                            return;

                        case 4: // '\004'
                            ((RequestManagerDeferred) (uri)).handler.post(uri. new Runnable() {

                                final RequestManagerObserver this$1;
                                final RequestManagerDeferred val$deferred;

                                public void run()
                                {
                                    if (deferred.isPending())
                                    {
                                        deferred.resolve(null);
                                        return;
                                    } else
                                    {
                                        ALog.d("MessageRequestManager: No deferred. Most likely already resolved", new Object[0]);
                                        return;
                                    }
                                }

            
            {
                this$1 = final_requestmanagerobserver;
                deferred = RequestManagerDeferred.this;
                super();
            }
                            });
                            break;
                        }
                        return;
                    }
                }
            }
        }

        public RequestManagerObserver(Handler handler)
        {
            this$0 = RequestManager.this;
            super(handler);
            matcher = new UriMatcher(-1);
            matcher.addURI("com.olio.server.request.Requests", "/requests/#", 0);
        }
    }

    static interface RequestProgress
    {

        public abstract long requestRow();
    }


    private static final String REQUEST_MANAGER_BACKGROUND_THREAD = "com.olio.RequestManagerThread";
    private static RequestManager SINGLETON = new RequestManager();
    private static long deleteOldRequestsLastTime = 0L;
    private BluetoothOnLoadListener bluetoothListener;
    private BluetoothStatusLoader bluetoothStatusLoader;
    private ConcurrentHashMap callbackCache;
    private ContentResolver contentResolver;
    private RequestManagerObserver observer;
    private Handler observerHandler;
    private HandlerThread observerThread;

    private RequestManager()
    {
        contentResolver = null;
        observer = null;
        observerThread = null;
        observerHandler = null;
        bluetoothStatusLoader = null;
        bluetoothListener = null;
        callbackCache = new ConcurrentHashMap();
    }

    public static void enqueueRequest(Context context, Message message)
    {
        if (message != null && context != null)
        {
            com.olio.server.request.RequestsContract.Requests.insertAsync(context.getContentResolver(), message);
            long l = System.currentTimeMillis();
            long l1 = TimeUnit.HOURS.toMillis(1L);
            if (deleteOldRequestsLastTime < l - l1)
            {
                deleteOldRequestsLastTime = System.currentTimeMillis();
                com.olio.server.request.RequestsContract.Requests.deleteOldRequests(context.getContentResolver());
            }
            return;
        } else
        {
            ALog.w("Tried to enqueue a null request.", new Object[0]);
            return;
        }
    }

    public static transient void enqueueRequests(ContentResolver contentresolver, Message amessage[])
    {
        com.olio.server.request.RequestsContract.Requests.batchInsertAsync(contentresolver, amessage);
    }

    public static RequestManager getInstance()
    {
        return SINGLETON;
    }

    public static void updateStatusForRequest(long l, int i, ContentResolver contentresolver)
    {
        if (l == -1L)
        {
            return;
        } else
        {
            ALog.d("MessageRequestManager: updating status for request: %d", new Object[] {
                Long.valueOf(l)
            });
            com.olio.server.request.RequestsContract.Requests.setStatusForRequest(contentresolver, com.olio.server.request.RequestsContract.Requests.uriForId(l), i);
            return;
        }
    }

    public static void updateStatusForRequest(Uri uri, int i, ContentResolver contentresolver)
    {
        ALog.d("MessageRequestManager: updateStatusForRequest for URI: %s and status %d", new Object[] {
            uri.toString(), Integer.valueOf(i)
        });
        com.olio.server.request.RequestsContract.Requests.setStatusForRequest(contentresolver, uri, i);
    }

    public void destroyRequestManager()
    {
        if (observer != null)
        {
            contentResolver.unregisterContentObserver(observer);
            observer = null;
        }
        if (observerThread != null)
        {
            observerThread.quit();
            observerThread = null;
            observerHandler = null;
        }
        if (bluetoothStatusLoader != null)
        {
            bluetoothStatusLoader.unregisterListener(bluetoothListener);
            bluetoothStatusLoader.stopLoading();
            bluetoothStatusLoader = null;
            bluetoothListener = null;
        }
    }

    public Promise enqueueRequestWithPromise(ContentResolver contentresolver, Message message, final Handler handler, final Context deferred)
    {
        deferred = new RequestManagerDeferred(handler, deferred);
        ALog.d("MessageRequestManager: enqueueRequestWithPromise called", new Object[0]);
        if (message == null || contentresolver == null || !BluetoothStatus.isBluetoothConnected(contentresolver, com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.Platform.WATCH))
        {
            ALog.w("Tried to enqueue a null request.", new Object[0]);
            handler.post(new Runnable() {

                final RequestManager this$0;
                final RequestManagerDeferred val$deferred;

                public void run()
                {
                    deferred.fail(null);
                }

            
            {
                this$0 = RequestManager.this;
                deferred = requestmanagerdeferred;
                super();
            }
            });
            return deferred.promise();
        }
        com.olio.server.request.RequestsContract.Requests.insertAsyncWithPromise(contentresolver, message, handler).done(new DoneCallback() {

            final RequestManager this$0;
            final RequestManagerDeferred val$deferred;
            final Handler val$handler;

            public void onDone(Long long1)
            {
                ALog.d("MessageRequestManager: Got done callback", new Object[0]);
                if (long1 != null)
                {
                    callbackCache.put(long1, deferred);
                    return;
                } else
                {
                    handler.post(new Runnable() {

                        final _cls3 this$1;

                        public void run()
                        {
                            deferred.fail(null);
                        }

            
            {
                this$1 = _cls3.this;
                super();
            }
                    });
                    return;
                }
            }

            public volatile void onDone(Object obj)
            {
                onDone((Long)obj);
            }

            
            {
                this$0 = RequestManager.this;
                deferred = requestmanagerdeferred;
                handler = handler1;
                super();
            }
        }).fail(new FailCallback() {

            final RequestManager this$0;
            final RequestManagerDeferred val$deferred;
            final Handler val$handler;

            public volatile void onFail(Object obj)
            {
                onFail((Throwable)obj);
            }

            public void onFail(Throwable throwable)
            {
                ALog.e("MessageRequestManager: Unable to insert in RequestManager", throwable, new Object[0]);
                handler.post(new Runnable() {

                    final _cls2 this$1;

                    public void run()
                    {
                        deferred.fail(null);
                    }

            
            {
                this$1 = _cls2.this;
                super();
            }
                });
            }

            
            {
                this$0 = RequestManager.this;
                handler = handler1;
                deferred = requestmanagerdeferred;
                super();
            }
        });
        long l = System.currentTimeMillis();
        long l1 = TimeUnit.HOURS.toMillis(1L);
        if (deleteOldRequestsLastTime < l - l1)
        {
            deleteOldRequestsLastTime = System.currentTimeMillis();
            com.olio.server.request.RequestsContract.Requests.deleteOldRequests(contentresolver);
        }
        return deferred.promise();
    }

    public void initializeRequestManager(ContentResolver contentresolver, Context context)
    {
        this;
        JVM INSTR monitorenter ;
        contentResolver = contentresolver;
        if (observer == null)
        {
            observerThread = new HandlerThread("com.olio.RequestManagerThread");
            observerThread.start();
            observerHandler = new Handler(observerThread.getLooper());
            observer = new RequestManagerObserver(observerHandler);
            contentresolver.registerContentObserver(com.olio.server.request.RequestsContract.Requests.CONTENT_URI, true, observer);
        }
        if (bluetoothStatusLoader == null)
        {
            bluetoothStatusLoader = new BluetoothStatusLoader(context);
            bluetoothStatusLoader.startLoading();
            bluetoothListener = new BluetoothOnLoadListener();
            bluetoothStatusLoader.registerListener(0x84a5c, bluetoothListener);
        }
        this;
        JVM INSTR monitorexit ;
        return;
        contentresolver;
        throw contentresolver;
    }





    // Unreferenced inner class com/olio/server/RequestManager$RequestManagerDeferred$1

/* anonymous class */
    class RequestManagerDeferred._cls1
        implements Runnable
    {

        final RequestManagerDeferred this$0;

        public void run()
        {
            if (isPending())
            {
                reject(null);
            }
        }

            
            {
                this$0 = RequestManagerDeferred.this;
                super();
            }
    }

}