/*
 * Copyright (C) 2022 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 android.app.sdksandbox.sdkprovider;

import static android.app.sdksandbox.SdkSandboxManager.getResultCodeForLoadSdkException;
import static android.app.sdksandbox.sdkprovider.SdkSandboxController.SDK_SANDBOX_CONTROLLER_SERVICE;

import android.annotation.CallbackExecutor;
import android.annotation.FlaggedApi;
import android.annotation.NonNull;
import android.annotation.SystemService;
import android.app.Activity;
import android.app.sdksandbox.AppOwnedSdkSandboxInterface;
import android.app.sdksandbox.ILoadSdkCallback;
import android.app.sdksandbox.LoadSdkException;
import android.app.sdksandbox.SandboxLatencyInfo;
import android.app.sdksandbox.SandboxedSdk;
import android.app.sdksandbox.SandboxedSdkContext;
import android.app.sdksandbox.SandboxedSdkProvider;
import android.app.sdksandbox.SdkSandboxLocalSingleton;
import android.app.sdksandbox.SdkSandboxManager;
import android.app.sdksandbox.StatsdUtil;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Bundle;
import android.os.IBinder;
import android.os.OutcomeReceiver;
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.Log;

import androidx.annotation.RequiresApi;

import com.android.modules.utils.build.SdkLevel;
import com.android.sdksandbox.flags.Flags;

import java.util.List;
import java.util.Objects;
import java.util.concurrent.Executor;

/**
 * Controller that is used by SDK loaded in the sandbox to access information provided by the sdk
 * sandbox.
 *
 * <p>It enables the SDK to communicate with other SDKS in the SDK sandbox and know about the state
 * of the sdks that are currently loaded in it.
 *
 * <p>An instance of {@link SdkSandboxController} can be obtained using {@link
 * Context#getSystemService} and {@link SdkSandboxController class}. The {@link Context} can in turn
 * be obtained using {@link android.app.sdksandbox.SandboxedSdkProvider#getContext()}.
 */
@SystemService(SDK_SANDBOX_CONTROLLER_SERVICE)
public class SdkSandboxController {
    public static final String SDK_SANDBOX_CONTROLLER_SERVICE = "sdk_sandbox_controller_service";
    /** @hide */
    public static final String CLIENT_SHARED_PREFERENCES_NAME =
            "com.android.sdksandbox.client_sharedpreferences";

    private static final String TAG = "SdkSandboxController";

    private SdkSandboxLocalSingleton mSdkSandboxLocalSingleton;
    private SdkSandboxActivityRegistry mSdkSandboxActivityRegistry;
    private Context mContext;

    /**
     * Create SdkSandboxController.
     *
     * @hide
     */
    public SdkSandboxController(@NonNull Context context) {
        // When SdkSandboxController is initiated from inside the sdk sandbox process, its private
        // members will be immediately rewritten by the initialize method.
        initialize(context);
    }

    /**
     * Initializes {@link SdkSandboxController} with the given {@code context}.
     *
     * <p>This method is called by the {@link SandboxedSdkContext} to propagate the correct context.
     * For more information check the javadoc on the {@link
     * android.app.sdksandbox.SdkSandboxSystemServiceRegistry}.
     *
     * @hide
     * @see android.app.sdksandbox.SdkSandboxSystemServiceRegistry
     */
    public SdkSandboxController initialize(@NonNull Context context) {
        mContext = context;
        mSdkSandboxLocalSingleton = SdkSandboxLocalSingleton.getExistingInstance();
        mSdkSandboxActivityRegistry = SdkSandboxActivityRegistry.getInstance();
        return this;
    }

    /**
     * Fetches all {@link AppOwnedSdkSandboxInterface} that are registered by the app.
     *
     * @return List of {@link AppOwnedSdkSandboxInterface} containing all currently registered
     *     AppOwnedSdkSandboxInterface.
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context
     */
    public @NonNull List<AppOwnedSdkSandboxInterface> getAppOwnedSdkSandboxInterfaces() {
        enforceSandboxedSdkContextInitialization();
        try {
            return mSdkSandboxLocalSingleton
                    .getSdkToServiceCallback()
                    .getAppOwnedSdkSandboxInterfaces(
                            ((SandboxedSdkContext) mContext).getClientPackageName());
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    /**
     * Fetches information about Sdks that are loaded in the sandbox.
     *
     * @return List of {@link SandboxedSdk} containing all currently loaded sdks
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context
     */
    public @NonNull List<SandboxedSdk> getSandboxedSdks() {
        enforceSandboxedSdkContextInitialization();
        SandboxLatencyInfo sandboxLatencyInfo =
                new SandboxLatencyInfo(SandboxLatencyInfo.METHOD_GET_SANDBOXED_SDKS_VIA_CONTROLLER);
        // TODO(b/319659746) : Rename the method to something more generic than using App.
        // TODO(b/321909787) : Use injector to set time in order to write unit tests.
        sandboxLatencyInfo.setTimeAppCalledSystemServer(SystemClock.elapsedRealtime());

        try {
            return mSdkSandboxLocalSingleton
                    .getSdkToServiceCallback()
                    .getSandboxedSdks(
                            ((SandboxedSdkContext) mContext).getClientPackageName(),
                            sandboxLatencyInfo);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    /**
     * Loads SDK in an SDK sandbox java process.
     *
     * <p>Loads SDK library with {@code sdkName} to an SDK sandbox process asynchronously. The
     * caller will be notified through the {@code receiver}.
     *
     * <p>The caller may only load {@code SDKs} the client app depends on into the SDK sandbox.
     *
     * @param sdkName name of the SDK to be loaded.
     * @param params additional parameters to be passed to the SDK in the form of a {@link Bundle}
     *     as agreed between the client and the SDK.
     * @param executor the {@link Executor} on which to invoke the receiver.
     * @param receiver This either receives a {@link SandboxedSdk} on a successful run, or {@link
     *     LoadSdkException}.
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context
     */
    public void loadSdk(
            @NonNull String sdkName,
            @NonNull Bundle params,
            @NonNull @CallbackExecutor Executor executor,
            @NonNull OutcomeReceiver<SandboxedSdk, LoadSdkException> receiver) {
        enforceSandboxedSdkContextInitialization();
        final LoadSdkReceiverProxy callbackProxy = new LoadSdkReceiverProxy(executor, receiver);
        SandboxLatencyInfo sandboxLatencyInfo =
                new SandboxLatencyInfo(SandboxLatencyInfo.METHOD_LOAD_SDK_VIA_CONTROLLER);
        // TODO(b/319659746) : Rename the method to something more generic than using App.
        // TODO(b/321909787) : Use injector to set time in order to write unit tests.
        sandboxLatencyInfo.setTimeAppCalledSystemServer(SystemClock.elapsedRealtime());

        try {
            mSdkSandboxLocalSingleton
                    .getSdkToServiceCallback()
                    .loadSdk(
                            ((SandboxedSdkContext) mContext).getClientPackageName(),
                            sdkName,
                            sandboxLatencyInfo,
                            params,
                            callbackProxy);
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    /**
     * Returns {@link SharedPreferences} containing data synced from the client app.
     *
     * <p>Keys that have been synced by the client app using {@link
     * SdkSandboxManager#addSyncedSharedPreferencesKeys(Set)} can be found in this {@link
     * SharedPreferences}.
     *
     * <p>The returned {@link SharedPreferences} should only be read. Writing to it is not
     * supported.
     *
     * @return {@link SharedPreferences} containing data synced from client app.
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context
     */
    @NonNull
    public SharedPreferences getClientSharedPreferences() {
        enforceSandboxedSdkContextInitialization();

        // TODO(b/248214708): We should store synced data in a separate internal storage directory.
        return mContext.getApplicationContext()
                .getSharedPreferences(CLIENT_SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE);
    }

    /**
     * Returns an identifier for a {@link SdkSandboxActivityHandler} after registering it.
     *
     * <p>This function registers an implementation of {@link SdkSandboxActivityHandler} created by
     * an SDK and returns an {@link IBinder} which uniquely identifies the passed {@link
     * SdkSandboxActivityHandler} object.
     *
     * <p>If the same {@link SdkSandboxActivityHandler} registered multiple times without
     * unregistering, the same {@link IBinder} token will be returned.
     *
     * @param sdkSandboxActivityHandler is the {@link SdkSandboxActivityHandler} to register.
     * @return {@link IBinder} uniquely identify the passed {@link SdkSandboxActivityHandler}.
     */
    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
    @NonNull
    public IBinder registerSdkSandboxActivityHandler(
            @NonNull SdkSandboxActivityHandler sdkSandboxActivityHandler) {
        if (!SdkLevel.isAtLeastU()) {
            throw new UnsupportedOperationException();
        }
        // TODO(b/321909787) : Use injector to set time for unit tests.
        long timeEventStarted = SystemClock.elapsedRealtime();
        enforceSandboxedSdkContextInitialization();

        IBinder token =
                mSdkSandboxActivityRegistry.register(
                        (SandboxedSdkContext) mContext, sdkSandboxActivityHandler);
        logSandboxActivityApiLatency(
                StatsdUtil
                        .SANDBOX_ACTIVITY_EVENT_OCCURRED__METHOD__REGISTER_SDK_SANDBOX_ACTIVITY_HANDLER,
                StatsdUtil.SANDBOX_ACTIVITY_EVENT_OCCURRED__CALL_RESULT__SUCCESS,
                timeEventStarted);
        return token;
    }

    /**
     * Unregister an already registered {@link SdkSandboxActivityHandler}.
     *
     * <p>If the passed {@link SdkSandboxActivityHandler} is registered, it will be unregistered.
     * Otherwise, it will do nothing.
     *
     * <p>After unregistering, SDK can register the same handler object again or create a new one in
     * case it wants a new {@link Activity}.
     *
     * <p>If the {@link IBinder} token of the unregistered handler used to start a {@link Activity},
     * the {@link Activity} will fail to start.
     *
     * @param sdkSandboxActivityHandler is the {@link SdkSandboxActivityHandler} to unregister.
     */
    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
    @NonNull
    public void unregisterSdkSandboxActivityHandler(
            @NonNull SdkSandboxActivityHandler sdkSandboxActivityHandler) {
        if (!SdkLevel.isAtLeastU()) {
            throw new UnsupportedOperationException();
        }
        long timeEventStarted = SystemClock.elapsedRealtime();
        enforceSandboxedSdkContextInitialization();

        mSdkSandboxActivityRegistry.unregister(sdkSandboxActivityHandler);
        logSandboxActivityApiLatency(
                StatsdUtil
                        .SANDBOX_ACTIVITY_EVENT_OCCURRED__METHOD__UNREGISTER_SDK_SANDBOX_ACTIVITY_HANDLER,
                StatsdUtil.SANDBOX_ACTIVITY_EVENT_OCCURRED__CALL_RESULT__SUCCESS,
                timeEventStarted);
    }

    /**
     * Returns the package name of the client app.
     *
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context.
     */
    @NonNull
    public String getClientPackageName() {
        enforceSandboxedSdkContextInitialization();
        return ((SandboxedSdkContext) mContext).getClientPackageName();
    }

    /**
     * Registers a listener to be notified of changes in the client's {@link
     * android.app.ActivityManager.RunningAppProcessInfo#importance}.
     *
     * @param listener an implementation of {@link SdkSandboxClientImportanceListener} to register.
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context.
     */
    @FlaggedApi(Flags.FLAG_SANDBOX_CLIENT_IMPORTANCE_LISTENER)
    public void registerSdkSandboxClientImportanceListener(
            @NonNull @CallbackExecutor Executor executor,
            @NonNull SdkSandboxClientImportanceListener listener) {
        Objects.requireNonNull(executor, "executor should not be null");
        Objects.requireNonNull(listener, "listener should not be null");
        enforceSandboxedSdkContextInitialization();
        SdkSandboxLocalSingleton.getExistingInstance()
                .registerSdkSandboxClientImportanceListener(
                        new SdkSandboxClientImportanceListenerProxy(executor, listener));
    }

    /**
     * Unregisters a listener previously registered using {@link
     * SdkSandboxController#registerSdkSandboxClientImportanceListener(Executor,
     * SdkSandboxClientImportanceListener)}
     *
     * @param listener an implementation of {@link SdkSandboxClientImportanceListener} to
     *     unregister.
     * @throws UnsupportedOperationException if the controller is obtained from an unexpected
     *     context. Use {@link SandboxedSdkProvider#getContext()} for the right context.
     */
    @FlaggedApi(Flags.FLAG_SANDBOX_CLIENT_IMPORTANCE_LISTENER)
    public void unregisterSdkSandboxClientImportanceListener(
            @NonNull SdkSandboxClientImportanceListener listener) {
        Objects.requireNonNull(listener, "listener should not be null");
        enforceSandboxedSdkContextInitialization();
        SdkSandboxLocalSingleton.getExistingInstance()
                .unregisterSdkSandboxClientImportanceListener(listener);
    }

    /** @hide */
    public static class SdkSandboxClientImportanceListenerProxy {
        private final Executor mExecutor;
        public final SdkSandboxClientImportanceListener listener;

        SdkSandboxClientImportanceListenerProxy(
                Executor executor, SdkSandboxClientImportanceListener listener) {
            mExecutor = executor;
            this.listener = listener;
        }

        /** @hide */
        public void onForegroundImportanceChanged(boolean isForeground) {
            mExecutor.execute(() -> listener.onForegroundImportanceChanged(isForeground));
        }
    }

    private void enforceSandboxedSdkContextInitialization() {
        if (!(mContext instanceof SandboxedSdkContext)) {
            throw new UnsupportedOperationException(
                    "Only available from the context obtained by calling android.app.sdksandbox"
                            + ".SandboxedSdkProvider#getContext()");
        }
    }

    private void logLatenciesFromSandbox(SandboxLatencyInfo sandboxLatencyInfo) {
        // TODO(b/319659746) : Rename the method to something more generic than using App.
        sandboxLatencyInfo.setTimeAppReceivedCallFromSystemServer(SystemClock.elapsedRealtime());
        try {
            mSdkSandboxLocalSingleton
                    .getSdkToServiceCallback()
                    .logLatenciesFromSandbox(sandboxLatencyInfo);
        } catch (RemoteException e) {
            Log.e(
                    TAG,
                    "Logging metrics for method "
                            + sandboxLatencyInfo.getMethod()
                            + " failed with exception "
                            + e.getMessage());
        }
    }

    private void logSandboxActivityApiLatency(int method, int callResult, long timeEventStarted) {
        try {
            mSdkSandboxLocalSingleton
                    .getSdkToServiceCallback()
                    .logSandboxActivityApiLatencyFromSandbox(
                            method,
                            callResult,
                            (int) (SystemClock.elapsedRealtime() - timeEventStarted));
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }

    private class LoadSdkReceiverProxy extends ILoadSdkCallback.Stub {
        private final Executor mExecutor;
        private final OutcomeReceiver<SandboxedSdk, LoadSdkException> mCallback;

        LoadSdkReceiverProxy(
                Executor executor, OutcomeReceiver<SandboxedSdk, LoadSdkException> callback) {
            mExecutor = executor;
            mCallback = callback;
        }

        @Override
        public void onLoadSdkSuccess(
                SandboxedSdk sandboxedSdk, SandboxLatencyInfo sandboxLatencyInfo) {
            SdkSandboxController.this.logLatenciesFromSandbox(sandboxLatencyInfo);
            mExecutor.execute(() -> mCallback.onResult(sandboxedSdk));
        }

        @Override
        public void onLoadSdkFailure(
                LoadSdkException exception, SandboxLatencyInfo sandboxLatencyInfo) {
            sandboxLatencyInfo.setResultCode(getResultCodeForLoadSdkException(exception));
            SdkSandboxController.this.logLatenciesFromSandbox(sandboxLatencyInfo);
            mExecutor.execute(() -> mCallback.onError(exception));
        }
    }
}