/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * 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.android.server.ambientcontext;

import android.annotation.NonNull;
import android.annotation.UserIdInt;
import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.ActivityTaskManager;
import android.app.AppGlobals;
import android.app.BroadcastOptions;
import android.app.PendingIntent;
import android.app.ambientcontext.AmbientContextEvent;
import android.app.ambientcontext.AmbientContextEventRequest;
import android.app.ambientcontext.AmbientContextManager;
import android.app.ambientcontext.IAmbientContextObserver;
import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ParceledListSlice;
import android.content.pm.ServiceInfo;
import android.os.Binder;
import android.os.Bundle;
import android.os.RemoteCallback;
import android.os.RemoteException;
import android.service.ambientcontext.AmbientContextDetectionResult;
import android.service.ambientcontext.AmbientContextDetectionServiceStatus;
import android.text.TextUtils;
import android.util.IndentingPrintWriter;
import android.util.Slog;

import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.server.infra.AbstractPerUserSystemService;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/**
 * Base per-user manager service for {@link AmbientContextEvent}s.
 */
abstract class AmbientContextManagerPerUserService extends
        AbstractPerUserSystemService<AmbientContextManagerPerUserService,
                AmbientContextManagerService> {
    private static final String TAG =
            AmbientContextManagerPerUserService.class.getSimpleName();

    /**
     * The type of service.
     */
    enum ServiceType {
        DEFAULT,
        WEARABLE
    }

    AmbientContextManagerPerUserService(
            @NonNull AmbientContextManagerService master, Object lock, @UserIdInt int userId) {
        super(master, lock, userId);
    }

    /**
     * Returns the current bound AmbientContextManagerPerUserService component for this user.
     */
    abstract ComponentName getComponentName();

    /**
     * Sets the component name for the per user service.
     */
    abstract void setComponentName(ComponentName componentName);

    /**
     * Ensures that the remote service is initiated.
     */
    abstract void ensureRemoteServiceInitiated();

    /**
     * Returns the AmbientContextManagerPerUserService {@link ServiceType} for this user.
     */
    abstract ServiceType getServiceType();

    /**
     * Returns the int config for the consent component for the
     * specific AmbientContextManagerPerUserService type
     */
    abstract int getConsentComponentConfig();

    /**
     * Returns the int config for the intent extra key for the
     * caller's package name while requesting ambient context consent.
     */
    abstract int getAmbientContextPackageNameExtraKeyConfig();

    /**
     * Returns the int config for the Intent extra key for the event code int array while
     * requesting ambient context consent.
     */
    abstract int getAmbientContextEventArrayExtraKeyConfig();

    /**
     * Returns the permission that is required to bind to this service.
     */
    abstract String getProtectedBindPermission();

    /**
     * Returns the remote service implementation for this user.
     */
    abstract RemoteAmbientDetectionService getRemoteService();

    /**
     * Clears the remote service.
     */
    abstract void clearRemoteService();

    /**
     * Called when there's an application with the callingPackage name is requesting for
     * the AmbientContextDetection's service status.
     *
     * @param eventTypes the event types to query for
     * @param callingPackage the package query for information
     * @param statusCallback the callback to deliver the status on
     */
    public void onQueryServiceStatus(int[] eventTypes, String callingPackage,
            RemoteCallback statusCallback) {
        Slog.d(TAG, "Query event status of " + Arrays.toString(eventTypes)
                + " for " + callingPackage);
        synchronized (mLock) {
            if (!setUpServiceIfNeeded()) {
                Slog.w(TAG, "Detection service is not available at this moment.");
                sendStatusCallback(statusCallback,
                        AmbientContextManager.STATUS_SERVICE_UNAVAILABLE);
                return;
            }
            ensureRemoteServiceInitiated();
            getRemoteService().queryServiceStatus(
                    eventTypes,
                    callingPackage,
                    getServerStatusCallback(
                            statusCode -> sendStatusCallback(statusCallback, statusCode)));
        }
    }

    /**
     * Unregisters the client from all previously registered events by removing from the
     * mExistingRequests map, and unregister events from the service if those events are not
     * requested by other apps.
     */
    public void onUnregisterObserver(String callingPackage) {
        synchronized (mLock) {
            stopDetection(callingPackage);
            mMaster.clientRemoved(mUserId, callingPackage);
        }
    }

    /**
     * Starts the consent activity for the calling package and event types.
     */
    public void onStartConsentActivity(int[] eventTypes, String callingPackage) {
        Slog.d(TAG, "Opening consent activity of " + Arrays.toString(eventTypes)
                + " for " + callingPackage);

        // Look up the recent task from the callingPackage
        ActivityManager.RecentTaskInfo task;
        ParceledListSlice<ActivityManager.RecentTaskInfo> recentTasks;
        int userId = getUserId();
        try {
            recentTasks = ActivityTaskManager.getService().getRecentTasks(/*maxNum*/1,
                    /*flags*/ 0, userId);
        } catch (RemoteException e) {
            Slog.e(TAG, "Failed to query recent tasks!");
            return;
        }

        if ((recentTasks == null) || recentTasks.getList().isEmpty()) {
            Slog.e(TAG, "Recent task list is empty!");
            return;
        }

        task = recentTasks.getList().get(0);
        if (!callingPackage.equals(task.topActivityInfo.packageName)) {
            Slog.e(TAG, "Recent task package name: " + task.topActivityInfo.packageName
                    + " doesn't match with client package name: " + callingPackage);
            return;
        }

        // Start activity as the same task from the callingPackage
        ComponentName consentComponent = getConsentComponent();
        if (consentComponent == null) {
            Slog.e(TAG, "Consent component not found!");
            return;
        }

        Slog.d(TAG, "Starting consent activity for " + callingPackage);
        Intent intent = new Intent();
        final long identity = Binder.clearCallingIdentity();
        try {
            Context context = getContext();
            String packageNameExtraKey = context.getResources().getString(
                    getAmbientContextPackageNameExtraKeyConfig());
            String eventArrayExtraKey = context.getResources().getString(
                    getAmbientContextEventArrayExtraKeyConfig());

            // Create consent activity intent with the calling package name and requested events
            intent.setComponent(consentComponent);
            if (packageNameExtraKey != null) {
                intent.putExtra(packageNameExtraKey, callingPackage);
            } else {
                Slog.d(TAG, "Missing packageNameExtraKey for consent activity");
            }
            if (eventArrayExtraKey != null) {
                intent.putExtra(eventArrayExtraKey, eventTypes);
            } else {
                Slog.d(TAG, "Missing eventArrayExtraKey for consent activity");
            }

            // Set parent to the calling app's task
            ActivityOptions options = ActivityOptions.makeBasic();
            options.setLaunchTaskId(task.taskId);
            context.startActivityAsUser(intent, options.toBundle(), context.getUser());
        } catch (ActivityNotFoundException e) {
            Slog.e(TAG, "unable to start consent activity");
        } finally {
            Binder.restoreCallingIdentity(identity);
        }
    }

    /**
     * Handles client registering as an observer. Only one registration is supported per app
     * package. A new registration from the same package will overwrite the previous registration.
     */
    public void onRegisterObserver(AmbientContextEventRequest request,
            String packageName, IAmbientContextObserver observer) {
        synchronized (mLock) {
            if (!setUpServiceIfNeeded()) {
                Slog.w(TAG, "Detection service is not available at this moment.");
                completeRegistration(observer, AmbientContextManager.STATUS_SERVICE_UNAVAILABLE);
                return;
            }

            // Register package and add to existing ClientRequests cache
            startDetection(request, packageName, observer);
            mMaster.newClientAdded(mUserId, request, packageName, observer);
        }
    }

    @Override
    protected ServiceInfo newServiceInfoLocked(@NonNull ComponentName serviceComponent)
            throws PackageManager.NameNotFoundException {
        Slog.d(TAG, "newServiceInfoLocked with component name: "
                + serviceComponent.getClassName());

        if (getComponentName() == null
                || !serviceComponent.getClassName().equals(getComponentName().getClassName())) {
            Slog.d(TAG, "service name does not match this per user, returning...");
            return null;
        }

        ServiceInfo serviceInfo;
        try {
            serviceInfo = AppGlobals.getPackageManager().getServiceInfo(serviceComponent,
                    0, mUserId);
            if (serviceInfo != null) {
                final String permission = serviceInfo.permission;
                if (!getProtectedBindPermission().equals(
                        permission)) {
                    throw new SecurityException(String.format(
                            "Service %s requires %s permission. Found %s permission",
                            serviceInfo.getComponentName(),
                            getProtectedBindPermission(),
                            serviceInfo.permission));
                }
            }
        } catch (RemoteException e) {
            throw new PackageManager.NameNotFoundException(
                    "Could not get service for " + serviceComponent);
        }
        return serviceInfo;
    }

    /**
     * Dumps the remote service.
     */
    protected void dumpLocked(@NonNull String prefix, @NonNull PrintWriter pw) {
        synchronized (super.mLock) {
            super.dumpLocked(prefix, pw);
        }
        RemoteAmbientDetectionService remoteService = getRemoteService();
        if (remoteService != null) {
            remoteService.dump("", new IndentingPrintWriter(pw, "  "));
        }
    }

    /**
     * Send request to the remote AmbientContextDetectionService impl to stop detecting the
     * specified events. Intended for use by shell command for testing.
     * Requires ACCESS_AMBIENT_CONTEXT_EVENT permission.
     */
    @VisibleForTesting
    protected void stopDetection(String packageName) {
        Slog.d(TAG, "Stop detection for " + packageName);
        synchronized (mLock) {
            if (getComponentName() != null) {
                ensureRemoteServiceInitiated();
                RemoteAmbientDetectionService remoteService = getRemoteService();
                remoteService.stopDetection(packageName);
            }
        }
    }

    /**
     * Destroys this service and unbinds from the remote service.
     */
    protected void destroyLocked() {
        Slog.d(TAG, "Trying to cancel the remote request. Reason: Service destroyed.");
        RemoteAmbientDetectionService remoteService = getRemoteService();
        if (remoteService != null) {
            synchronized (mLock) {
                remoteService.unbind();
                clearRemoteService();
            }
        }
    }

    /**
     * Send request to the remote AmbientContextDetectionService impl to start detecting the
     * specified events. Intended for use by shell command for testing.
     * Requires ACCESS_AMBIENT_CONTEXT_EVENT permission.
     */
    protected void startDetection(AmbientContextEventRequest request, String callingPackage,
            IAmbientContextObserver observer) {
        Slog.d(TAG, "Requested detection of " + request.getEventTypes());
        synchronized (mLock) {
            if (setUpServiceIfNeeded()) {
                ensureRemoteServiceInitiated();
                RemoteAmbientDetectionService remoteService = getRemoteService();
                remoteService.startDetection(request, callingPackage,
                        createDetectionResultRemoteCallback(),
                        getServerStatusCallback(
                                statusCode -> completeRegistration(observer, statusCode)));
            } else {
                Slog.w(TAG, "No valid component found for AmbientContextDetectionService");
                completeRegistration(observer,
                        AmbientContextManager.STATUS_NOT_SUPPORTED);
            }
        }
    }

    /**
     * Notifies the observer the status of the registration.
     *
     * @param observer the observer to notify
     * @param statusCode the status to notify
     */
    protected void completeRegistration(IAmbientContextObserver observer, int statusCode) {
        try {
            observer.onRegistrationComplete(statusCode);
        } catch (RemoteException e) {
            Slog.w(TAG, "Failed to call IAmbientContextObserver.onRegistrationComplete: "
                    + e.getMessage());
        }
    }

    /**
     * Sends the status on the {@link RemoteCallback}.
     *
     * @param statusCallback the callback to send the status on
     * @param statusCode the status to send
     */
    protected void sendStatusCallback(RemoteCallback statusCallback,
            @AmbientContextManager.StatusCode int statusCode) {
        Bundle bundle = new Bundle();
        bundle.putInt(
                AmbientContextManager.STATUS_RESPONSE_BUNDLE_KEY,
                statusCode);
        statusCallback.sendResult(bundle);
    }

    /**
     * Sends out the Intent to the client after the event is detected.
     *
     * @param pendingIntent Client's PendingIntent for callback
     * @param events detected events from the detection service
     */
    protected void sendDetectionResultIntent(PendingIntent pendingIntent,
            List<AmbientContextEvent> events) {
        Intent intent = new Intent();
        intent.putExtra(AmbientContextManager.EXTRA_AMBIENT_CONTEXT_EVENTS,
                new ArrayList(events));
        // Explicitly disallow the receiver from starting activities, to prevent apps from utilizing
        // the PendingIntent as a backdoor to do this.
        BroadcastOptions options = BroadcastOptions.makeBasic();
        options.setPendingIntentBackgroundActivityLaunchAllowed(false);
        try {
            pendingIntent.send(getContext(), 0, intent, null,
                    null, null, options.toBundle());
            Slog.i(TAG, "Sending PendingIntent to " + pendingIntent.getCreatorPackage() + ": "
                    + events);
        } catch (PendingIntent.CanceledException e) {
            Slog.w(TAG, "Couldn't deliver pendingIntent:" + pendingIntent);
        }
    }

    @NonNull
    protected RemoteCallback createDetectionResultRemoteCallback() {
        return new RemoteCallback(result -> {
            AmbientContextDetectionResult detectionResult =
                    (AmbientContextDetectionResult) result.get(
                            AmbientContextDetectionResult.RESULT_RESPONSE_BUNDLE_KEY);
            String packageName = detectionResult.getPackageName();
            IAmbientContextObserver observer = mMaster.getClientRequestObserver(
                    mUserId, packageName);
            if (observer == null) {
                return;
            }

            final long token = Binder.clearCallingIdentity();
            try {
                observer.onEvents(detectionResult.getEvents());
                Slog.i(TAG, "Got detection result of " + detectionResult.getEvents()
                        + " for " + packageName);
            } catch (RemoteException e) {
                Slog.w(TAG, "Failed to call IAmbientContextObserver.onEvents: " + e.getMessage());
            } finally {
                Binder.restoreCallingIdentity(token);
            }
        });
    }

    /**
     * Resolves and sets up the service if it had not been done yet. Returns true if the service
     * is available.
     */
    @GuardedBy("mLock")
    @VisibleForTesting
    private boolean setUpServiceIfNeeded() {
        if (getComponentName() == null) {
            ComponentName[] componentNames = updateServiceInfoListLocked();
            if (componentNames == null || componentNames.length != 2) {
                Slog.d(TAG, "updateServiceInfoListLocked returned incorrect componentNames");
                return false;
            }

            switch (getServiceType()) {
                case DEFAULT:
                    setComponentName(componentNames[0]);
                    break;
                case WEARABLE:
                    setComponentName(componentNames[1]);
                    break;
                default:
                    Slog.d(TAG, "updateServiceInfoListLocked returned unknown service types.");
                    return false;
            }
        }

        if (getComponentName() == null) {
            return false;
        }

        ServiceInfo serviceInfo;
        try {
            serviceInfo = AppGlobals.getPackageManager().getServiceInfo(
                    getComponentName(), 0, mUserId);
        } catch (RemoteException e) {
            Slog.w(TAG, "RemoteException while setting up service");
            return false;
        }
        return serviceInfo != null;
    }

    /**
     * Returns a RemoteCallback that handles the status from the detection service, and
     * sends results to the client callback.
     */
    private RemoteCallback getServerStatusCallback(Consumer<Integer> statusConsumer) {
        return new RemoteCallback(result -> {
            AmbientContextDetectionServiceStatus serviceStatus =
                    (AmbientContextDetectionServiceStatus) result.get(
                            AmbientContextDetectionServiceStatus.STATUS_RESPONSE_BUNDLE_KEY);
            final long token = Binder.clearCallingIdentity();
            try {
                int statusCode = serviceStatus.getStatusCode();
                statusConsumer.accept(statusCode);
                Slog.i(TAG, "Got detection status of " + statusCode
                        + " for " + serviceStatus.getPackageName());
            } finally {
                Binder.restoreCallingIdentity(token);
            }
        });
    }

    /**
     * Returns the consent activity component from config lookup.
     */
    private ComponentName getConsentComponent() {
        Context context = getContext();
        String consentComponent = context.getResources().getString(getConsentComponentConfig());
        if (TextUtils.isEmpty(consentComponent)) {
            return null;
        }
        Slog.i(TAG, "Consent component name: " + consentComponent);
        return ComponentName.unflattenFromString(consentComponent);
    }
}