/*
 * Copyright 2016, 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.managedprovisioning.preprovisioning;

import static android.content.res.Configuration.UI_MODE_NIGHT_MASK;
import static android.content.res.Configuration.UI_MODE_NIGHT_YES;
import static android.nfc.NfcAdapter.ACTION_NDEF_DISCOVERED;

import static com.android.managedprovisioning.model.ProvisioningParams.FLOW_TYPE_LEGACY;
import static com.android.managedprovisioning.preprovisioning.PreProvisioningViewModel.STATE_PREPROVISIONING_INITIALIZING;
import static com.android.managedprovisioning.preprovisioning.PreProvisioningViewModel.STATE_SHOWING_USER_CONSENT;
import static com.android.managedprovisioning.provisioning.Constants.PROVISIONING_SERVICE_INTENT;

import static com.google.android.setupcompat.util.WizardManagerHelper.EXTRA_IS_SETUP_FLOW;

import android.app.Activity;
import android.app.BackgroundServiceStartNotAllowedException;
import android.app.DialogFragment;
import android.content.ComponentName;
import android.content.Intent;
import android.os.Bundle;
import android.provider.Settings;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.View;
import android.widget.TextView;

import androidx.annotation.VisibleForTesting;

import com.android.managedprovisioning.ManagedProvisioningScreens;
import com.android.managedprovisioning.R;
import com.android.managedprovisioning.analytics.MetricsWriterFactory;
import com.android.managedprovisioning.analytics.ProvisioningAnalyticsTracker;
import com.android.managedprovisioning.common.AccessibilityContextMenuMaker;
import com.android.managedprovisioning.common.GetProvisioningModeUtils;
import com.android.managedprovisioning.common.Globals;
import com.android.managedprovisioning.common.LogoUtils;
import com.android.managedprovisioning.common.ManagedProvisioningSharedPreferences;
import com.android.managedprovisioning.common.ProvisionLogger;
import com.android.managedprovisioning.common.SettingsFacade;
import com.android.managedprovisioning.common.SetupGlifLayoutActivity;
import com.android.managedprovisioning.common.SimpleDialog;
import com.android.managedprovisioning.common.ThemeHelper;
import com.android.managedprovisioning.common.ThemeHelper.DefaultNightModeChecker;
import com.android.managedprovisioning.common.ThemeHelper.DefaultSetupWizardBridge;
import com.android.managedprovisioning.common.Utils;
import com.android.managedprovisioning.model.ProvisioningParams;
import com.android.managedprovisioning.preprovisioning.PreProvisioningActivityController.UiParams;
import com.android.managedprovisioning.provisioning.AdminIntegratedFlowPrepareActivity;
import com.android.managedprovisioning.provisioning.ProvisioningActivity;
import com.android.managedprovisioning.provisioning.ProvisioningService;

import com.google.android.setupcompat.util.WizardManagerHelper;

public class PreProvisioningActivity extends SetupGlifLayoutActivity implements
        SimpleDialog.SimpleDialogListener, PreProvisioningActivityController.Ui {

    private static final int ENCRYPT_DEVICE_REQUEST_CODE = 1;
    @VisibleForTesting
    protected static final int PROVISIONING_REQUEST_CODE = 2;
    private static final int WIFI_REQUEST_CODE = 3;
    private static final int CHANGE_LAUNCHER_REQUEST_CODE = 4;
    private static final int ORGANIZATION_OWNED_LANDING_PAGE_REQUEST_CODE = 5;
    private static final int GET_PROVISIONING_MODE_REQUEST_CODE = 6;
    private static final int FINANCED_DEVICE_PREPARE_REQUEST_CODE = 7;
    private static final int ADMIN_INTEGRATED_FLOW_PREPARE_REQUEST_CODE = 8;

    // Note: must match the constant defined in HomeSettings
    private static final String EXTRA_SUPPORT_MANAGED_PROFILES = "support_managed_profiles";

    private static final String ERROR_AND_CLOSE_DIALOG = "PreProvErrorAndCloseDialog";
    private static final String BACK_PRESSED_DIALOG_RESET = "PreProvBackPressedDialogReset";
    private static final String BACK_PRESSED_DIALOG_CLOSE_ACTIVITY =
            "PreProvBackPressedDialogCloseActivity";
    private static final String LAUNCHER_INVALID_DIALOG = "PreProvCurrentLauncherInvalidDialog";

    private PreProvisioningActivityController mController;
    private ControllerProvider mControllerProvider;
    private final AccessibilityContextMenuMaker mContextMenuMaker;
    private PreProvisioningActivityBridge mBridge;
    private boolean mShouldForwardTransition;

    private static final String ERROR_DIALOG_RESET = "ErrorDialogReset";

    public PreProvisioningActivity() {
        this(activity ->
                new PreProvisioningActivityController(activity, activity),
                null,
                new Utils(),
                new SettingsFacade(),
                new ThemeHelper(
                    new DefaultNightModeChecker(),
                    new DefaultSetupWizardBridge()));
    }

    @VisibleForTesting
    public PreProvisioningActivity(
            ControllerProvider controllerProvider,
            AccessibilityContextMenuMaker contextMenuMaker, Utils utils,
            SettingsFacade settingsFacade, ThemeHelper themeHelper) {
        super(utils, settingsFacade, themeHelper);
        mControllerProvider = controllerProvider;
        mContextMenuMaker =
                contextMenuMaker != null ? contextMenuMaker : new AccessibilityContextMenuMaker(
                        this);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO(b/192074477): Remove deferred setup-specific logic after the managed account flow
        //  starts ManagedProvisioning with the isSetupFlow extra
        // TODO(b/178822333): Remove NFC-specific logic after adding support for the
        //  admin-integrated flow
        // This temporary fix only works when called before super.onCreate
        if (mSettingsFacade.isDeferredSetup(getApplicationContext()) || isNfcSetup()) {
            getIntent().putExtra(EXTRA_IS_SETUP_FLOW, true);
        }

        super.onCreate(savedInstanceState);
        mController = mControllerProvider.getInstance(this);
        mBridge = createBridge();
        mController.getState().observe(this, this::onStateChanged);
        logMetrics();
    }

    @Override
    protected void onStart() {
        super.onStart();
        try {
            getApplicationContext().startService(PROVISIONING_SERVICE_INTENT);
        } catch (BackgroundServiceStartNotAllowedException e) {
            ProvisionLogger.loge(e);
        }
    }

    private boolean isNfcSetup() {
        return ACTION_NDEF_DISCOVERED.equals(getIntent().getAction());
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (mShouldForwardTransition) {
            overridePendingTransition(R.anim.sud_slide_next_in, R.anim.sud_slide_next_out);
            mShouldForwardTransition = false;
        }
    }

    protected PreProvisioningActivityBridge createBridge() {
        return new PreProvisioningActivityBridgeImpl(
                /* activity= */ this,
                mUtils,
                PreProvisioningActivity.this::initializeLayoutParams,
                createBridgeCallbacks(),
                getThemeHelper());
    }

    protected final PreProvisioningActivityBridgeCallbacks createBridgeCallbacks() {
        return new PreProvisioningActivityBridgeCallbacks() {
            @Override
            public void onTermsAccepted() {
                mController.continueProvisioningAfterUserConsent();
            }

            @Override
            public void onTermsButtonClicked() {
                getTransitionHelper()
                        .startActivityWithTransition(PreProvisioningActivity.this,
                                mController.createViewTermsIntent());
            }
        };
    }

    private void onStateChanged(Integer state) {
        switch (state) {
            case STATE_PREPROVISIONING_INITIALIZING:
                mController.initiateProvisioning(getIntent(), getCallingPackage());
                break;
            case STATE_SHOWING_USER_CONSENT:
                mController.showUserConsentScreen();
                break;
        }
    }

    @Override
    public void finish() {
        // The user has backed out of provisioning, so we perform the necessary clean up steps.
        LogoUtils.cleanUp(this);
        ProvisioningParams params = mController.getParams();
        if (params != null) {
            params.cleanUp();
        }
        getEncryptionController().cancelEncryptionReminder();
        getApplicationContext().stopService(PROVISIONING_SERVICE_INTENT);
        super.finish();
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch (requestCode) {
            case ENCRYPT_DEVICE_REQUEST_CODE:
                if (resultCode == RESULT_CANCELED) {
                    ProvisionLogger.loge("User canceled device encryption.");
                }
                break;
            case PROVISIONING_REQUEST_CODE:
                mController.onReturnFromProvisioning();
                setResult(resultCode);
                getTransitionHelper().finishActivity(this);
                break;
            case CHANGE_LAUNCHER_REQUEST_CODE:
                mController.continueProvisioningAfterUserConsent();
                break;
            case WIFI_REQUEST_CODE:
                if (resultCode == RESULT_CANCELED) {
                    ProvisionLogger.loge("User canceled wifi picking.");
                    setResult(resultCode);
                    getTransitionHelper().finishActivity(this);
                } else {
                    if (resultCode == RESULT_OK) {
                        ProvisionLogger.logd("Wifi request result is OK");
                    }
                    mController.initiateProvisioning(getIntent(), getCallingPackage());
                }
                break;
            case ORGANIZATION_OWNED_LANDING_PAGE_REQUEST_CODE:
            case ADMIN_INTEGRATED_FLOW_PREPARE_REQUEST_CODE:
                if (resultCode == RESULT_OK) {
                    // TODO(b/177849035): Remove NFC-specific logic
                    if (mController.getParams().isNfc) {
                        mController.startNfcFlow();
                    } else {
                        handleAdminIntegratedFlowPreparerResult();
                    }
                } else {
                    ProvisionLogger.loge(
                            "Provisioning was aborted in the preparation stage, "
                                    + "requestCode = " + requestCode);
                    if (isDpcInstalled()
                            && mUtils.isOrganizationOwnedAllowed(mController.getParams())) {
                        showFactoryResetDialog(R.string.cant_set_up_device,
                                R.string.contact_your_admin_for_help);
                    } else {
                        showErrorAndClose(
                                R.string.cant_set_up_device,
                                R.string.contact_your_admin_for_help,
                                "Failed provisioning device.");
                    }
                }
                break;
            case GET_PROVISIONING_MODE_REQUEST_CODE:
                mShouldForwardTransition = true;
                if (resultCode == RESULT_OK) {
                    if(data != null && mController.updateProvisioningParamsFromIntent(data)) {
                        mController.showUserConsentScreen();
                    } else {
                        ProvisionLogger.loge(
                                "Invalid data object returned from GET_PROVISIONING_MODE.");
                        if (mUtils.isOrganizationOwnedAllowed(mController.getParams())) {
                            showFactoryResetDialog(R.string.cant_set_up_device,
                                    R.string.contact_your_admin_for_help);
                        } else {
                            showErrorAndClose(
                                    R.string.cant_set_up_device,
                                    R.string.contact_your_admin_for_help,
                                    "Failed provisioning personally-owned device.");
                        }
                    }
                } else {
                    ProvisionLogger.loge("Invalid result code from GET_PROVISIONING_MODE. Expected "
                            + RESULT_OK + " but got " + resultCode + ".");
                    if (mUtils.isOrganizationOwnedAllowed(mController.getParams())) {
                        showFactoryResetDialog(R.string.cant_set_up_device,
                                R.string.contact_your_admin_for_help);
                    } else {
                        showErrorAndClose(
                                R.string.cant_set_up_device,
                                R.string.contact_your_admin_for_help,
                                "Failed to provision personally-owned device.");
                    }
                }
                break;
            case FINANCED_DEVICE_PREPARE_REQUEST_CODE:
                if (resultCode == RESULT_OK) {
                    startFinancedDeviceFlow();
                } else {
                    setResult(resultCode);
                    getTransitionHelper().finishActivity(this);
                }
                break;
            default:
                ProvisionLogger.logw("Unknown result code :" + resultCode);
                break;
        }
    }

    private boolean isDpcInstalled() {
        String adminPackageName = mController.getParams().inferDeviceAdminPackageName();
        return mUtils.isPackageInstalled(adminPackageName, getPackageManager());
    }

    private void handleAdminIntegratedFlowPreparerResult() {
        if (isDpcInstalled()) {
            startAdminIntegratedFlowPostDpcInstall();
        } else {
            String adminPackageName = mController.getParams().inferDeviceAdminPackageName();
            showErrorAndClose(
                    R.string.cant_set_up_device,
                    R.string.contact_your_admin_for_help,
                    "Package name " + adminPackageName + " is not installed.");
        }
    }

    @Override
    public void showErrorAndClose(Integer titleId, int messageId, String logText) {
        ProvisionLogger.loge(logText);

        SimpleDialog.Builder dialogBuilder = new SimpleDialog.Builder()
                .setTitle(titleId)
                .setMessage(messageId)
                .setCancelable(false)
                .setPositiveButtonMessage(R.string.device_owner_error_ok);
        showDialog(dialogBuilder, ERROR_AND_CLOSE_DIALOG);
    }

    @Override
    public void onNegativeButtonClick(DialogFragment dialog) {
        switch (dialog.getTag()) {
            case BACK_PRESSED_DIALOG_CLOSE_ACTIVITY:
            case BACK_PRESSED_DIALOG_RESET:
                // user chose to continue. Do nothing
                break;
            case LAUNCHER_INVALID_DIALOG:
                dialog.dismiss();
                break;
            default:
                SimpleDialog.throwButtonClickHandlerNotImplemented(dialog);
        }
    }

    @Override
    public void onPositiveButtonClick(DialogFragment dialog) {
        switch (dialog.getTag()) {
            case ERROR_AND_CLOSE_DIALOG:
            case BACK_PRESSED_DIALOG_CLOSE_ACTIVITY:
                onProvisioningAborted();
                break;
            case BACK_PRESSED_DIALOG_RESET:
                mUtils.factoryReset(this, "Provisioning cancelled by user on consent screen");
                onProvisioningAborted();
                break;
            case LAUNCHER_INVALID_DIALOG:
                requestLauncherPick();
                break;
            case ERROR_DIALOG_RESET:
                getUtils().factoryReset(this, "Error during preprovisioning");
                setResult(Activity.RESULT_CANCELED);
                getTransitionHelper().finishActivity(this);
                break;
            default:
                SimpleDialog.throwButtonClickHandlerNotImplemented(dialog);
        }
    }

    private void onProvisioningAborted() {
        setResult(Activity.RESULT_CANCELED);
        mController.logPreProvisioningCancelled();
        getTransitionHelper().finishActivity(this);
    }

    @Override
    public void requestEncryption(ProvisioningParams params) {
        Intent encryptIntent = new Intent(this,
                getActivityForScreen(ManagedProvisioningScreens.ENCRYPT));
        WizardManagerHelper.copyWizardManagerExtras(getIntent(), encryptIntent);
        encryptIntent.putExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS, params);
        getTransitionHelper().startActivityForResultWithTransition(
                this, encryptIntent, ENCRYPT_DEVICE_REQUEST_CODE);
    }

    @Override
    public void requestWifiPick() {
        final Intent intent = mUtils.getWifiPickIntent();
        WizardManagerHelper.copyWizardManagerExtras(getIntent(), intent);
        getTransitionHelper()
                .startActivityForResultWithTransition(this, intent, WIFI_REQUEST_CODE);
    }

    @Override
    public void showCurrentLauncherInvalid() {
        SimpleDialog.Builder dialogBuilder = new SimpleDialog.Builder()
                .setCancelable(false)
                .setTitle(R.string.change_device_launcher)
                .setMessage(R.string.launcher_app_cant_be_used_by_work_profile)
                .setNegativeButtonMessage(R.string.cancel_provisioning)
                .setPositiveButtonMessage(R.string.pick_launcher);
        showDialog(dialogBuilder, LAUNCHER_INVALID_DIALOG);
    }

    @Override
    public void abortProvisioning() {
        onProvisioningAborted();
    }

    @Override
    public void prepareAdminIntegratedFlow(ProvisioningParams params) {
        if (AdminIntegratedFlowPrepareActivity.shouldRunPrepareActivity(mUtils, this, params)) {
            Intent intent = new Intent(this,
                    getActivityForScreen(ManagedProvisioningScreens.ADMIN_INTEGRATED_PREPARE));
            WizardManagerHelper.copyWizardManagerExtras(getIntent(), intent);
            intent.putExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS, params);
            getTransitionHelper().startActivityForResultWithTransition(
                    this, intent, ADMIN_INTEGRATED_FLOW_PREPARE_REQUEST_CODE);
        } else {
            handleAdminIntegratedFlowPreparerResult();
        }
    }

    private void requestLauncherPick() {
        Intent changeLauncherIntent = new Intent(Settings.ACTION_HOME_SETTINGS);
        changeLauncherIntent.putExtra(EXTRA_SUPPORT_MANAGED_PROFILES, true);
        getTransitionHelper().startActivityForResultWithTransition(
                this, changeLauncherIntent, CHANGE_LAUNCHER_REQUEST_CODE);
    }

    /**
     * Starts {@link ProvisioningActivity}.
     */
    public void startProvisioning(ProvisioningParams params) {
        Intent intent = new Intent(this,
                getActivityForScreen(ManagedProvisioningScreens.PROVISIONING));
        WizardManagerHelper.copyWizardManagerExtras(getIntent(), intent);
        intent.putExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS, params);
        getTransitionHelper().startActivityForResultWithTransition(
                this, intent, PROVISIONING_REQUEST_CODE);
    }

    // TODO: The below group of methods do not belong in the activity.
    // Move them to the controller instead.
    /**
     * Starts either the admin-integrated or the legacy flow, depending on the device state and
     * DPC capabilities.
     */
    private void startAdminIntegratedFlowPostDpcInstall() {
        boolean canPerformAdminIntegratedFlow = mUtils.canPerformAdminIntegratedFlow(
                this,
                mController.getParams(),
                mController.getPolicyComplianceUtils(),
                mController.getGetProvisioningModeUtils());
        if (canPerformAdminIntegratedFlow) {
            startAdminIntegratedFlowWithoutPredeterminedMode();
        } else {
            ProvisionLogger.loge("The admin app does not have handlers for both "
                    + "ACTION_GET_PROVISIONING_MODE and ACTION_ADMIN_POLICY_COMPLIANCE "
                    + "intent actions.");
            if (mUtils.isOrganizationOwnedAllowed(mController.getParams())) {
                showFactoryResetDialog(R.string.cant_set_up_device,
                        R.string.contact_your_admin_for_help);
            } else {
                showErrorAndClose(
                        R.string.cant_set_up_device,
                        R.string.contact_your_admin_for_help,
                        "Failed provisioning personally-owned device.");
            }
        }
        mController.logProvisioningFlowType();
    }

    private void startAdminIntegratedFlowWithoutPredeterminedMode() {
        ProvisionLogger.logi("Starting the admin-integrated flow.");
        GetProvisioningModeUtils provisioningModeUtils = mController.getGetProvisioningModeUtils();
        Bundle additionalExtras = mController.getAdditionalExtrasForGetProvisioningModeIntent();
        provisioningModeUtils.startGetProvisioningModeActivityIfResolved(
                this, mController.getParams(), additionalExtras,
                GET_PROVISIONING_MODE_REQUEST_CODE, getTransitionHelper());
    }

    private void startFinancedDeviceFlow() {
        ProvisionLogger.logi("Starting the financed device flow.");
        mController.updateProvisioningFlowState(FLOW_TYPE_LEGACY);
        mController.continueProvisioningAfterUserConsent();
    }

    @Override
    public void showFactoryResetDialog(Integer titleId, int messageId) {
        SimpleDialog.Builder dialogBuilder = new SimpleDialog.Builder()
                .setTitle(titleId)
                .setMessage(messageId)
                .setCancelable(false)
                .setPositiveButtonMessage(R.string.reset);

        showDialog(dialogBuilder, ERROR_DIALOG_RESET);
    }

    @Override
    public void initiateUi(UiParams uiParams) {
        mBridge.initiateUi(uiParams);
    }

    @Override
    public void showOwnershipDisclaimerScreen(ProvisioningParams params) {
        Intent intent = new Intent(this,
                getActivityForScreen(ManagedProvisioningScreens.LANDING));
        WizardManagerHelper.copyWizardManagerExtras(getIntent(), intent);
        intent.putExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS, params);
        getTransitionHelper().startActivityForResultWithTransition(
                this, intent, ORGANIZATION_OWNED_LANDING_PAGE_REQUEST_CODE);
    }

    @Override
    public void prepareFinancedDeviceFlow(ProvisioningParams params) {
        Intent intent = new Intent(this,
                getActivityForScreen(ManagedProvisioningScreens.FINANCED_DEVICE_LANDING));
        WizardManagerHelper.copyWizardManagerExtras(getIntent(), intent);
        intent.putExtra(ProvisioningParams.EXTRA_PROVISIONING_PARAMS, params);
        getTransitionHelper().startActivityForResultWithTransition(
                this, intent, FINANCED_DEVICE_PREPARE_REQUEST_CODE);
    }

    @Override
    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
        super.onCreateContextMenu(menu, v, menuInfo);
        if (v instanceof TextView) {
            mContextMenuMaker.populateMenuContent(menu, (TextView) v);
        }
    }

    @Override
    public void onBackPressed() {
        if (mUtils.isOrganizationOwnedAllowed(mController.getParams())) {
            showDialog(mUtils.createCancelProvisioningResetDialogBuilder(),
                    BACK_PRESSED_DIALOG_RESET);
        } else {
            showDialog(mUtils.createCancelProvisioningDialogBuilder(),
                    BACK_PRESSED_DIALOG_CLOSE_ACTIVITY);
        }
    }

    private void logMetrics() {
        final ProvisioningAnalyticsTracker analyticsTracker =
                new ProvisioningAnalyticsTracker(
                        MetricsWriterFactory.getMetricsWriter(this, new SettingsFacade()),
                        new ManagedProvisioningSharedPreferences(this));
        int nightMode = getResources().getConfiguration().uiMode & UI_MODE_NIGHT_MASK;
        analyticsTracker.logIsNightMode(nightMode == UI_MODE_NIGHT_YES);
    }

    /**
     * Constructs {@link PreProvisioningActivityController} for a given {@link
     * PreProvisioningActivity}
     */
    interface ControllerProvider {
        /**
         * Constructs {@link PreProvisioningActivityController} for a given {@link
         * PreProvisioningActivity}
         */
        PreProvisioningActivityController getInstance(PreProvisioningActivity activity);
    }
}