// 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.request;

import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.net.Uri;
import android.os.Handler;
import android.provider.BaseColumns;
import com.olio.communication.messages.Message;
import com.olio.util.ALog;
import java.lang.ref.WeakReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.jdeferred.Deferred;
import org.jdeferred.Promise;
import org.jdeferred.impl.DeferredObject;

// Referenced classes of package com.olio.server.request:
//            RequestProvider

public final class RequestsContract
{
    private static class BatchInsertTask
        implements Runnable
    {

        private final WeakReference crRef;
        private final Message messages[];

        public void run()
        {
            ALog.d("BatchInsert=START", new Object[0]);
            ContentResolver contentresolver = (ContentResolver)crRef.get();
            if (contentresolver != null)
            {
                ALog.d("BatchInsert=FETCH_CONTENT_RESOLVER, Status=IS_VALID", new Object[0]);
                ALog.d("BatchInsert=GATHERING_MESSAGES, Count=%d", new Object[] {
                    Integer.valueOf(messages.length)
                });
                ContentValues acontentvalues[] = new ContentValues[messages.length];
                for (int i = 0; i < messages.length; i++)
                {
                    acontentvalues[i] = Requests.contentValuesFor(messages[i]);
                }

                ALog.d("BatchInsert=ISSUE_INSERT, Uri='Requests.CONTENT_URI', Count=%d", new Object[] {
                    Integer.valueOf(messages.length)
                });
                contentresolver.bulkInsert(Requests.CONTENT_URI, acontentvalues);
            } else
            {
                ALog.d("BatchInsert=FETCH_CONTENT_RESOLVER, Status=IS_NOT_VALID", new Object[0]);
            }
            ALog.d("BatchInsert=END", new Object[0]);
        }

        public transient BatchInsertTask(ContentResolver contentresolver, Message amessage[])
        {
            crRef = new WeakReference(contentresolver);
            messages = amessage;
        }
    }

    public static final class Requests
        implements BaseColumns
    {

        public static final String COLUMN_NAME_DATE_CREATED = "dateCreated";
        public static final String COLUMN_NAME_DATE_MODIFIED = "dateModified";
        public static final String COLUMN_NAME_REQUEST_ID = "requestId";
        public static final String COLUMN_NAME_REQUEST_MESSAGE = "requestMessage";
        public static final String COLUMN_NAME_REQUEST_SOURCE = "requestSource";
        public static final String COLUMN_NAME_RESPONSE_MESSAGE = "responseMessage";
        public static final String COLUMN_NAME_RESPONSE_SOURCE = "responseSource";
        public static final String COLUMN_NAME_STATUS = "status";
        public static final Uri CONTENT_ID_URI_BASE = Uri.parse("content://com.olio.server.request.Requests/requests/");
        public static final Uri CONTENT_ID_URI_PATTERN = Uri.parse("content://com.olio.server.request.Requests/requests//#");
        public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.olio.request";
        public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.olio.request";
        public static final Uri CONTENT_URI = Uri.parse("content://com.olio.server.request.Requests/requests");
        public static final String DEFAULT_SORT_ORDER = "dateCreated DESC";
        public static final int INVALID_REQUEST_ID = -1;
        public static final String PATH_REQUEST = "/requests";
        private static final String PATH_REQUEST_ID = "/requests/";
        public static final int REQUEST_ID_PATH_POSITION = 1;
        public static final String SCHEME = "content://";
        public static final int STATUS_FAILED = 0;
        public static final int STATUS_INVALID = -1;
        public static final int STATUS_PAUSED = 1;
        public static final int STATUS_PENDING = 2;
        public static final int STATUS_RUNNING = 3;
        public static final int STATUS_SUCCESSFUL = 4;
        public static final String TABLE_NAME = "requests";
        static final ExecutorService sExecutor = Executors.newSingleThreadExecutor();

        public static transient void batchInsertAsync(ContentResolver contentresolver, Message amessage[])
        {
            sExecutor.execute(new BatchInsertTask(contentresolver, amessage));
        }

        public static final ContentValues contentValuesFor(Message message)
        {
            ContentValues contentvalues = new ContentValues();
            contentvalues.put("status", Integer.valueOf(2));
            contentvalues.put("requestMessage", message.encodeWithSerialization());
            contentvalues.put("requestSource", message.getSource());
            return contentvalues;
        }

        public static final ContentValues contentValuesFromCursor(Cursor cursor)
        {
            ContentValues contentvalues = new ContentValues();
            contentvalues.put("requestId", Long.valueOf(cursor.getLong(0)));
            contentvalues.put("status", Integer.valueOf(cursor.getInt(1)));
            contentvalues.put("requestMessage", cursor.getBlob(2));
            contentvalues.put("responseMessage", cursor.getBlob(3));
            contentvalues.put("requestSource", cursor.getString(4));
            contentvalues.put("responseSource", cursor.getString(5));
            contentvalues.put("dateCreated", cursor.getString(6));
            contentvalues.put("dateModified", cursor.getString(7));
            contentvalues.put("_id", Integer.valueOf(cursor.getInt(8)));
            return contentvalues;
        }

        public static void deleteOldRequests(ContentResolver contentresolver)
        {
            sExecutor.execute(new Runnable(contentresolver) {

                final ContentResolver val$contentResolver;

                public void run()
                {
                    String s = Long.toString(Long.valueOf(System.currentTimeMillis() - TimeUnit.HOURS.toMillis(1L)).longValue());
                    try
                    {
                        ALog.v("Deleted %s old requests", new Object[] {
                            Integer.valueOf(contentResolver.delete(Requests.CONTENT_URI, "dateCreated < ?", new String[] {
                                s
                            }))
                        });
                        return;
                    }
                    catch (Exception exception)
                    {
                        ALog.e("Exception deleting old requests.", exception, new Object[0]);
                    }
                }

            
            {
                contentResolver = contentresolver;
                super();
            }
            });
        }

        public static Cursor get(ContentResolver contentresolver, long l)
        {
            return contentresolver.query(CONTENT_URI, getColumnProjection(), "requestId = ?", new String[] {
                Long.toString(l)
            }, null);
        }

        static Cursor get(ContentResolver contentresolver, Uri uri)
        {
            return contentresolver.query(uri, getColumnProjection(), null, null, null);
        }

        public static final String[] getColumnProjection()
        {
            return (new String[] {
                "requestId", "status", "requestMessage", "responseMessage", "requestSource", "responseSource", "dateCreated", "dateModified", "_id"
            });
        }

        public static MessageStatus getMessage(ContentResolver contentresolver, long l)
        {
            return messageStatusForRow(get(contentresolver, l));
        }

        public static MessageStatus getMessage(ContentResolver contentresolver, Uri uri)
        {
            return messageStatusForRow(get(contentresolver, uri));
        }

        public static long idForUri(Uri uri)
        {
            if (RequestProvider.sUriMatcher.match(uri) == 2)
            {
                return Long.valueOf(uri.getLastPathSegment()).longValue();
            } else
            {
                return -1L;
            }
        }

        public static Long insert(ContentResolver contentresolver, Message message)
        {
            contentresolver = get(contentresolver, insertForUri(contentresolver, message));
            contentresolver.moveToFirst();
            message = contentValuesFromCursor(contentresolver).getAsLong("_id");
            contentresolver.close();
            return message;
        }

        public static void insertAsync(ContentResolver contentresolver, Message message)
        {
            sExecutor.execute(new Runnable(contentresolver, message) {

                final ContentResolver val$cr;
                final Message val$message;

                public void run()
                {
                    Requests.insert(cr, message);
                }

            
            {
                cr = contentresolver;
                message = message1;
                super();
            }
            });
        }

        public static Promise insertAsyncWithPromise(ContentResolver contentresolver, Message message, Handler handler)
        {
            DeferredObject deferredobject = new DeferredObject();
            handler.post(new Runnable(contentresolver, message, deferredobject) {

                final ContentResolver val$cr;
                final Deferred val$deferred;
                final Message val$message;

                public void run()
                {
                    Requests.sExecutor.execute(new Runnable() {

                        final Requests._cls1 this$0;

                        public void run()
                        {
                            try
                            {
                                Long long1 = Requests.insert(cr, message);
                                deferred.resolve(long1);
                                return;
                            }
                            catch (Exception exception)
                            {
                                deferred.reject(exception);
                            }
                        }

            
            {
                this$0 = Requests._cls1.this;
                super();
            }
                    });
                }

            
            {
                cr = contentresolver;
                message = message1;
                deferred = deferred1;
                super();
            }
            });
            return deferredobject.promise();
        }

        static Uri insertForUri(ContentResolver contentresolver, Message message)
        {
            return contentresolver.insert(CONTENT_URI, contentValuesFor(message));
        }

        private static MessageStatus messageStatusForRow(Cursor cursor)
        {
            Object obj;
            Object obj1;
            if (cursor == null)
            {
                return new MessageStatus(null, -1);
            }
            obj = null;
            obj1 = null;
            if (cursor.getCount() > 0)
            {
                cursor.moveToFirst();
                obj1 = contentValuesFromCursor(cursor);
                obj = Message.decodeFromSerialization(((ContentValues) (obj1)).getAsByteArray("requestMessage"));
                obj1 = new RequestsContractRequest(((ContentValues) (obj1)));
            }
            cursor.close();
            if (obj1 != null)
            {
                return new MessageStatus(((Message) (obj)), ((RequestsContractRequest) (obj1)).getStatus());
            } else
            {
                return new MessageStatus(((Message) (obj)), -1);
            }
            obj;
            cursor.close();
            throw obj;
        }

        public static Promise setStatusForRequest(ContentResolver contentresolver, Uri uri, int i)
        {
            DeferredObject deferredobject = new DeferredObject();
            ALog.d("MessageRequestManager: About to update values for uri: %s", new Object[] {
                uri.toString()
            });
            sExecutor.execute(new Runnable(i, contentresolver, uri, deferredobject) {

                final ContentResolver val$contentResolver;
                final Deferred val$deferred;
                final int val$status;
                final Uri val$uri;

                public void run()
                {
                    ContentValues contentvalues = new ContentValues(1);
                    contentvalues.put("status", Integer.valueOf(status));
                    int i = contentResolver.update(uri, contentvalues, null, null);
                    ALog.d("MessageRequestManager: Updated this many rows for uri: %s %d", new Object[] {
                        uri.toString(), Integer.valueOf(i)
                    });
                    deferred.resolve(Integer.valueOf(i));
                }

            
            {
                status = i;
                contentResolver = contentresolver;
                uri = uri1;
                deferred = deferred1;
                super();
            }
            });
            return deferredobject.promise();
        }

        public static Uri uriForId(long l)
        {
            return CONTENT_ID_URI_BASE.buildUpon().appendPath(String.valueOf(l)).build();
        }


        private Requests()
        {
        }
    }

    public static interface Requests.InsertCallback
    {

        public abstract void rowId(Long long1);
    }

    public static class Requests.MessageStatus
    {

        public Message message;
        public int status;

        public Requests.MessageStatus(Message message1, int i)
        {
            message = message1;
            status = i;
        }
    }

    public static class RequestsContractRequest
    {

        private ContentValues theValues;

        public static RequestsContractRequest requestFromUri(ContentResolver contentresolver, Uri uri)
        {
            ContentResolver contentresolver1 = null;
            contentresolver = Requests.get(contentresolver, uri);
            contentresolver1 = contentresolver;
            if (!contentresolver.moveToFirst())
            {
                break MISSING_BLOCK_LABEL_64;
            }
            contentresolver1 = contentresolver;
            uri = Requests.contentValuesFromCursor(contentresolver);
            contentresolver1 = contentresolver;
            RequestsContractRequest requestscontractrequest = new RequestsContractRequest();
            contentresolver1 = contentresolver;
            requestscontractrequest.theValues = uri;
            if (contentresolver != null && !contentresolver.isClosed())
            {
                contentresolver.close();
            }
            return requestscontractrequest;
            if (contentresolver != null && !contentresolver.isClosed())
            {
                contentresolver.close();
            }
            return null;
            contentresolver;
            if (contentresolver1 != null && !contentresolver1.isClosed())
            {
                contentresolver1.close();
            }
            throw contentresolver;
        }

        public String getDateCreated()
        {
            return theValues.getAsString("dateCreated");
        }

        public String getDateModified()
        {
            return theValues.getAsString("dateModified");
        }

        public long getRequestId()
        {
            return theValues.getAsLong("requestId").longValue();
        }

        public byte[] getRequestMessage()
        {
            return theValues.getAsByteArray("requestMessage");
        }

        public String getRequestSource()
        {
            return theValues.getAsString("requestSource");
        }

        public byte[] getResponseMessage()
        {
            return theValues.getAsByteArray("responseMessage");
        }

        public String getResponseSource()
        {
            return theValues.getAsString("responseSource");
        }

        public int getStatus()
        {
            return theValues.getAsInteger("status").intValue();
        }

        public void setDateCreated(String s)
        {
            theValues.put("dateCreated", s);
        }

        public void setDateModified(String s)
        {
            theValues.put("dateModified", s);
        }

        public void setRequestId(long l)
        {
            theValues.put("requestId", Long.valueOf(l));
        }

        public void setRequestMessage(byte abyte0[])
        {
            theValues.put("requestMessage", abyte0);
        }

        public void setRequestSource(String s)
        {
            theValues.put("requestSource", s);
        }

        public void setResponseMessage(byte abyte0[])
        {
            theValues.put("responseMessage", abyte0);
        }

        public void setResponseSource(String s)
        {
            theValues.put("responseSource", s);
        }

        public void setStatus(int i)
        {
            theValues.put("status", Integer.valueOf(i));
        }

        public RequestsContractRequest()
        {
            theValues = null;
            theValues = new ContentValues(8);
        }

        public RequestsContractRequest(ContentValues contentvalues)
        {
            theValues = null;
            theValues = contentvalues;
        }
    }


    public static final String AUTHORITY = "com.olio.server.request.Requests";

    private RequestsContract()
    {
    }
}