/**
 * Copyright 2010-present Facebook.
 *
 * 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.facebook;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;
import com.facebook.internal.LikeActionController;
import com.facebook.internal.NativeProtocol;
import com.facebook.internal.PendingCallStore;
import com.facebook.internal.Utility;
import com.facebook.widget.FacebookDialog;

import java.util.UUID;

/**
 * This class helps to create, automatically open (if applicable), save, and
 * restore the Active Session in a way that is similar to Android UI lifecycles.
 * <p>
 * When using this class, clients MUST call all the public methods from the
 * respective methods in either an Activity or Fragment. Failure to call all the
 * methods can result in improperly initialized or uninitialized Sessions.
 * <p>
 * This class should also be used by Activities that will be displaying native dialogs
 * provided by the Facebook application, in order to handle processing of the activity
 * results generated by those dialogs.
 */
public class UiLifecycleHelper {
    private static final String DIALOG_CALL_ID_SAVE_KEY =
            "com.facebook.UiLifecycleHelper.pendingFacebookDialogCallKey";

    private final static String ACTIVITY_NULL_MESSAGE = "activity cannot be null";

    private final Activity activity;
    private final Session.StatusCallback callback;
    private final BroadcastReceiver receiver;
    private final LocalBroadcastManager broadcastManager;
    // Members related to handling FacebookDialog calls
    private UUID pendingFacebookDialogCallId;
    private PendingCallStore pendingFacebookDialogCallStore;

    private AppEventsLogger appEventsLogger;

    /**
     * Creates a new UiLifecycleHelper.
     *
     * @param activity the Activity associated with the helper. If calling from a Fragment,
     *                 use {@link android.support.v4.app.Fragment#getActivity()}
     * @param callback the callback for Session status changes, can be null
     */
    public UiLifecycleHelper(Activity activity, Session.StatusCallback callback) {
        if (activity == null) {
            throw new IllegalArgumentException(ACTIVITY_NULL_MESSAGE);
        }

        this.activity = activity;
        this.callback = callback;
        this.receiver = new ActiveSessionBroadcastReceiver();
        this.broadcastManager = LocalBroadcastManager.getInstance(activity);
        this.pendingFacebookDialogCallStore = PendingCallStore.getInstance();

        // initialize SDK
        Settings.sdkInitialize(activity);
    }

    /**
     * To be called from an Activity or Fragment's onCreate method.
     *
     * @param savedInstanceState the previously saved state
     */
    public void onCreate(Bundle savedInstanceState) {
        Session session = Session.getActiveSession();
        if (session == null) {
            if (savedInstanceState != null) {
                session = Session.restoreSession(activity, null, callback, savedInstanceState);
            }
            if (session == null) {
                session = new Session(activity);
            }
            Session.setActiveSession(session);
        }
        if (savedInstanceState != null) {
            String callIdString = savedInstanceState.getString(DIALOG_CALL_ID_SAVE_KEY);
            if (callIdString != null) {
                pendingFacebookDialogCallId = UUID.fromString(callIdString);
            }
            pendingFacebookDialogCallStore.restoreFromSavedInstanceState(savedInstanceState);
        }
    }

    /**
     * To be called from an Activity or Fragment's onResume method.
     */
    public void onResume() {
        Session session = Session.getActiveSession();
        if (session != null) {
            if (callback != null) {
                session.addCallback(callback);
            }
            if (SessionState.CREATED_TOKEN_LOADED.equals(session.getState())) {
                session.openForRead(null);
            }
        }

        // add the broadcast receiver
        IntentFilter filter = new IntentFilter();
        filter.addAction(Session.ACTION_ACTIVE_SESSION_SET);
        filter.addAction(Session.ACTION_ACTIVE_SESSION_UNSET);

        // Add a broadcast receiver to listen to when the active Session
        // is set or unset, and add/remove our callback as appropriate
        broadcastManager.registerReceiver(receiver, filter);
    }

    /**
     * To be called from an Activity or Fragment's onActivityResult method.
     *
     * @param requestCode the request code
     * @param resultCode the result code
     * @param data the result data
     */
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        onActivityResult(requestCode, resultCode, data, null);
    }

    /**
     * To be called from an Activity or Fragment's onActivityResult method, when the results of a FacebookDialog
     * call are expected.
     *
     * @param requestCode the request code
     * @param resultCode the result code
     * @param data the result data
     * @param facebookDialogCallback the callback for handling FacebookDialog results, can be null
     */
    public void onActivityResult(int requestCode, int resultCode, Intent data,
                FacebookDialog.Callback facebookDialogCallback) {
        Session session = Session.getActiveSession();
        if (session != null) {
            session.onActivityResult(activity, requestCode, resultCode, data);
        }

        if (LikeActionController.handleOnActivityResult(activity, requestCode, resultCode, data)) {
            return;
        }

        handleFacebookDialogActivityResult(requestCode, resultCode, data, facebookDialogCallback);
    }

    /**
     * To be called from an Activity or Fragment's onSaveInstanceState method.
     *
     * @param outState the bundle to save state in
     */
    public void onSaveInstanceState(Bundle outState) {
        Session.saveSession(Session.getActiveSession(), outState);
        if (pendingFacebookDialogCallId != null) {
            outState.putString(DIALOG_CALL_ID_SAVE_KEY, pendingFacebookDialogCallId.toString());
        }
        pendingFacebookDialogCallStore.saveInstanceState(outState);
    }

    /**
     * To be called from an Activity or Fragment's onPause method.
     */
    public void onPause() {
        // remove the broadcast receiver
        broadcastManager.unregisterReceiver(receiver);

        if (callback != null) {
            Session session = Session.getActiveSession();
            if (session != null) {
                session.removeCallback(callback);
            }
        }
    }

    /**
     * To be called from an Activity or Fragment's onStop method.
     */
    public void onStop() {
        AppEventsLogger.onContextStop();
    }

    /**
     * To be called from an Activity or Fragment's onDestroy method.
     */
    public void onDestroy() {
    }

    /**
     * Register that we are expecting results from a call to the Facebook application (e.g., from a native
     * dialog provided by the Facebook app). Activity results forwarded to onActivityResults will be parsed
     * and handled if they correspond to this call. Only a single pending FacebookDialog call can be tracked
     * at a time; attempting to track another one will cancel the first one.
     * @param appCall an PendingCall object containing the call ID
     */
    public void trackPendingDialogCall(FacebookDialog.PendingCall pendingCall) {
        if (pendingFacebookDialogCallId != null) {
            // If one is already pending, cancel it; we don't allow multiple pending calls.
            Log.i("Facebook", "Tracking new app call while one is still pending; canceling pending call.");
            cancelPendingAppCall(null);
        }
        if (pendingCall != null){
            pendingFacebookDialogCallId = pendingCall.getCallId();
            pendingFacebookDialogCallStore.trackPendingCall(pendingCall);
        }
    }

    /**
     * Retrieves an instance of AppEventsLogger that can be used for the current Session, if any. Different
     * instances may be returned if the current Session changes, so this value should not be cached for long
     * periods of time -- always call getAppEventsLogger to get the right logger for the current Session. If
     * no Session is currently available, this method will return null.
     *
     * To ensure delivery of app events across Activity lifecycle events, calling Activities should be sure to
     * call the onStop method.
     *
     * @return an AppEventsLogger to use for logging app events
     */
    public AppEventsLogger getAppEventsLogger() {
        Session session = Session.getActiveSession();
        if (session == null) {
            return null;
        }

        if (appEventsLogger == null || !appEventsLogger.isValidForSession(session)) {
            if (appEventsLogger != null) {
                // Pretend we got stopped so the old logger will persist its results now, in case we get stopped
                // before events get flushed.
                AppEventsLogger.onContextStop();
            }
            appEventsLogger = AppEventsLogger.newLogger(activity, session);
        }

        return appEventsLogger;
    }

    /**
     * The BroadcastReceiver implementation that either adds or removes the callback
     * from the active Session object as it's SET or UNSET.
     */
    private class ActiveSessionBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (Session.ACTION_ACTIVE_SESSION_SET.equals(intent.getAction())) {
                Session session = Session.getActiveSession();
                if (session != null && callback != null) {
                    session.addCallback(callback);
                }
            } else if (Session.ACTION_ACTIVE_SESSION_UNSET.equals(intent.getAction())) {
                Session session = Session.getActiveSession();
                if (session != null && callback != null) {
                    session.removeCallback(callback);
                }
            }
        }
    }

    private boolean handleFacebookDialogActivityResult(int requestCode, int resultCode, Intent data,
            FacebookDialog.Callback facebookDialogCallback) {
        if (pendingFacebookDialogCallId == null) {
            return false;
        }
        FacebookDialog.PendingCall pendingCall =
                pendingFacebookDialogCallStore.getPendingCallById(pendingFacebookDialogCallId);
        if (pendingCall == null || pendingCall.getRequestCode() != requestCode) {
            return false;
        }

        if (data == null) {
            // We understand the request code, but have no Intent. This can happen if the called Activity crashes
            // before it can be started; we treat this as a cancellation because we have no other information.
            cancelPendingAppCall(facebookDialogCallback);
            return true;
        }

        UUID callId = NativeProtocol.getCallIdFromIntent(data);

        // Was this result for the call we are waiting on?
        if (callId != null && pendingFacebookDialogCallId.equals(callId)) {
            // Yes, we can handle it normally.
            FacebookDialog.handleActivityResult(activity, pendingCall, requestCode, data,
                    facebookDialogCallback);
        } else {
            // No, send a cancellation error to the pending call and ignore the result, because we
            // don't know what to do with it.
            cancelPendingAppCall(facebookDialogCallback);
        }

        stopTrackingPendingAppCall();
        return true;
    }

    private void cancelPendingAppCall(FacebookDialog.Callback facebookDialogCallback) {
        if (pendingFacebookDialogCallId == null) {
            return;
        }

        FacebookDialog.PendingCall pendingCall =
                pendingFacebookDialogCallStore.getPendingCallById(pendingFacebookDialogCallId);
        if (pendingCall == null) {
            return;
        }

        if (facebookDialogCallback != null) {
            Intent pendingIntent = pendingCall.getRequestIntent();

            Intent cancelIntent = new Intent();
            cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID,
                    pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_CALL_ID));
            cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION,
                    pendingIntent.getStringExtra(NativeProtocol.EXTRA_PROTOCOL_ACTION));
            cancelIntent.putExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION,
                    pendingIntent.getIntExtra(NativeProtocol.EXTRA_PROTOCOL_VERSION, 0));
            cancelIntent.putExtra(NativeProtocol.STATUS_ERROR_TYPE, NativeProtocol.ERROR_UNKNOWN_ERROR);

            FacebookDialog.handleActivityResult(activity, pendingCall,
                    pendingCall.getRequestCode(), cancelIntent, facebookDialogCallback);
        }

        stopTrackingPendingAppCall();
    }

    private void stopTrackingPendingAppCall() {
        pendingFacebookDialogCallStore.stopTrackingPendingCall(pendingFacebookDialogCallId);
        pendingFacebookDialogCallId = null;
    }
}
