/*
 * Copyright (C) 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.storagemanager.deletionhelper;

import android.Manifest;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.storage.StorageManager;
import androidx.annotation.VisibleForTesting;
import androidx.preference.PreferenceFragment;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import android.text.format.Formatter;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.internal.util.Preconditions;
import com.android.settingslib.HelpUtils;
import com.android.settingslib.applications.AppUtils;
import com.android.storagemanager.ButtonBarProvider;
import com.android.storagemanager.R;
import com.android.storagemanager.overlay.DeletionHelperFeatureProvider;
import com.android.storagemanager.overlay.FeatureFactory;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

/**
 * Settings screen for the deletion helper, which manually removes data which is not recently used.
 */
public class DeletionHelperSettings extends PreferenceFragment
        implements DeletionType.FreeableChangedListener, View.OnClickListener {
    public static final boolean COUNT_UNCHECKED = true;
    public static final boolean COUNT_CHECKED_ONLY = false;

    protected static final String APPS_KEY = "apps_group";
    protected static final String KEY_DOWNLOADS_PREFERENCE = "delete_downloads";
    protected static final String KEY_PHOTOS_VIDEOS_PREFERENCE = "delete_photos";
    protected static final String KEY_GAUGE_PREFERENCE = "deletion_gauge";

    private static final String THRESHOLD_KEY = "threshold_key";
    private static final int DOWNLOADS_LOADER_ID = 1;
    private static final int NUM_DELETION_TYPES = 3;
    private static final long UNSET = -1;

    private List<DeletionType> mDeletableContentList;
    private AppDeletionPreferenceGroup mApps;
    @VisibleForTesting AppDeletionType mAppBackend;
    @VisibleForTesting DownloadsDeletionPreferenceGroup mDownloadsPreference;
    private DownloadsDeletionType mDownloadsDeletion;
    private PhotosDeletionPreference mPhotoPreference;
    private Preference mGaugePreference;
    private DeletionType mPhotoVideoDeletion;
    private Button mCancel, mFree;
    private DeletionHelperFeatureProvider mProvider;
    private int mThresholdType;
    @VisibleForTesting long mBytesToFree = UNSET;
    private int mResult;
    private LoadingSpinnerController mLoadingController;

    public static DeletionHelperSettings newInstance(int thresholdType) {
        DeletionHelperSettings instance = new DeletionHelperSettings();
        Bundle bundle = new Bundle(1);
        bundle.putInt(THRESHOLD_KEY, thresholdType);
        instance.setArguments(bundle);
        return instance;
    }

    @Override
    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
        addPreferencesFromResource(R.xml.deletion_helper_list);
        mThresholdType = getArguments().getInt(THRESHOLD_KEY, AppsAsyncLoader.NORMAL_THRESHOLD);
        mApps = (AppDeletionPreferenceGroup) findPreference(APPS_KEY);
        mPhotoPreference = (PhotosDeletionPreference) findPreference(KEY_PHOTOS_VIDEOS_PREFERENCE);
        mProvider = FeatureFactory.getFactory(getActivity()).getDeletionHelperFeatureProvider();
        mLoadingController = new LoadingSpinnerController((DeletionHelperActivity) getActivity());
        if (mProvider != null) {
            mPhotoVideoDeletion =
                    mProvider.createPhotoVideoDeletionType(getContext(), mThresholdType);
        }

        HashSet<String> checkedApplications = null;
        if (savedInstanceState != null) {
            checkedApplications =
                    (HashSet<String>) savedInstanceState.getSerializable(
                            AppDeletionType.EXTRA_CHECKED_SET);
        }
        mAppBackend = new AppDeletionType(this, checkedApplications, mThresholdType);
        mAppBackend.registerView(mApps);
        mAppBackend.registerFreeableChangedListener(this);
        mApps.setDeletionType(mAppBackend);

        mDeletableContentList = new ArrayList<>(NUM_DELETION_TYPES);

        mGaugePreference = findPreference(KEY_GAUGE_PREFERENCE);
        Activity activity = getActivity();
        if (activity != null && mGaugePreference != null) {
            Intent intent = activity.getIntent();
            if (intent != null) {
                CharSequence gaugeTitle =
                        getGaugeString(getContext(), intent, activity.getCallingPackage());
                if (gaugeTitle != null) {
                    mGaugePreference.setTitle(gaugeTitle);

                    long requestedBytes =
                            intent.getLongExtra(StorageManager.EXTRA_REQUESTED_BYTES, UNSET);
                    mBytesToFree = requestedBytes;
                } else {
                    getPreferenceScreen().removePreference(mGaugePreference);
                }
            }
        }
    }

    protected static CharSequence getGaugeString(
            Context context, Intent intent, String packageName) {
        Preconditions.checkNotNull(intent);
        long requestedBytes = intent.getLongExtra(StorageManager.EXTRA_REQUESTED_BYTES, UNSET);
        if (requestedBytes > 0) {
            CharSequence callerLabel =
                    AppUtils.getApplicationLabel(context.getPackageManager(), packageName);
            // I really hope this isn't the case, but I can't ignore the possibility that we cannot
            // determine what app the referrer is.
            if (callerLabel == null) {
                return null;
            }
            return context.getString(
                    R.string.app_requesting_space,
                    callerLabel,
                    Formatter.formatFileSize(context, requestedBytes));
        }
        return null;
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        initializeButtons();
        setHasOptionsMenu(true);
        Activity activity = getActivity();
        if (activity.checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            activity.requestPermissions(
                    new String[] {Manifest.permission.READ_EXTERNAL_STORAGE},
                    0);
        }

        if (mProvider != null && mPhotoVideoDeletion != null) {
            mPhotoPreference.setDaysToKeep(mProvider.getDaysToKeep(mThresholdType));
            mPhotoPreference.registerFreeableChangedListener(this);
            mPhotoPreference.registerDeletionService(mPhotoVideoDeletion);
            mDeletableContentList.add(mPhotoVideoDeletion);
        } else {
            getPreferenceScreen().removePreference(mPhotoPreference);
            mPhotoPreference.setEnabled(false);
        }

        String[] uncheckedFiles = null;
        if (savedInstanceState != null) {
            uncheckedFiles =
                    savedInstanceState.getStringArray(
                            DownloadsDeletionType.EXTRA_UNCHECKED_DOWNLOADS);
        }
        mDownloadsPreference =
                (DownloadsDeletionPreferenceGroup) findPreference(KEY_DOWNLOADS_PREFERENCE);
        mDownloadsDeletion = new DownloadsDeletionType(getActivity(), uncheckedFiles);
        mDownloadsPreference.registerFreeableChangedListener(this);
        mDownloadsPreference.registerDeletionService(mDownloadsDeletion);
        mDeletableContentList.add(mDownloadsDeletion);
        if (isEmptyState()) {
            setupEmptyState();
        }
        mDeletableContentList.add(mAppBackend);
        updateFreeButtonText();
    }

    @VisibleForTesting
    void setupEmptyState() {
        final PreferenceScreen screen = getPreferenceScreen();
        if (mDownloadsPreference != null) {
            mDownloadsPreference.setChecked(false);
            screen.removePreference(mDownloadsPreference);
        }
        screen.removePreference(mApps);

        // Nulling out the downloads preferences means we won't accidentally delete what isn't
        // visible.
        mDownloadsDeletion = null;
        mDownloadsPreference = null;
    }

    private boolean isEmptyState() {
        // We know we are in the empty state if our loader is not using a threshold.
        return mThresholdType == AppsAsyncLoader.NO_THRESHOLD;
    }

    @Override
    public void onResume() {
        super.onResume();

        mLoadingController.initializeLoading(getListView());

        for (int i = 0, size = mDeletableContentList.size(); i < size; i++) {
            mDeletableContentList.get(i).onResume();
        }

        if (mDownloadsDeletion != null
                && getActivity().checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE)
                        == PackageManager.PERMISSION_GRANTED) {
            getLoaderManager().initLoader(DOWNLOADS_LOADER_ID, new Bundle(), mDownloadsDeletion);
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        for (int i = 0, size = mDeletableContentList.size(); i < size; i++) {
            mDeletableContentList.get(i).onPause();
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        for (int i = 0, size = mDeletableContentList.size(); i < size; i++) {
            mDeletableContentList.get(i).onSaveInstanceStateBundle(outState);
        }
    }

    @Override
    public void onFreeableChanged(int numItems, long bytesFreeable) {
        if (numItems > 0 || bytesFreeable > 0 || allTypesEmpty()) {
            if (mLoadingController != null) {
                mLoadingController.onCategoryLoad();
            }
        }

        // bytesFreeable is the number of bytes freed by a single deletion type. If it is non-zero,
        // there is stuff to free and we can enable it. If it is zero, though, we still need to get
        // getTotalFreeableSpace to check all deletion types.
        if (mFree != null) {
            mFree.setEnabled(bytesFreeable != 0 || getTotalFreeableSpace(COUNT_CHECKED_ONLY) != 0);
        }
        updateFreeButtonText();

        // Transition to empty state if all types have reported there is nothing to delete. Skip
        // the transition if we are already in no threshold mode
        if (allTypesEmpty() && !isEmptyState()) {
            startEmptyState();
        }
    }

    private boolean allTypesEmpty() {
        return mAppBackend.isEmpty()
                && (mDownloadsDeletion == null || mDownloadsDeletion.isEmpty())
                && (mPhotoVideoDeletion == null || mPhotoVideoDeletion.isEmpty());
    }

    private void startEmptyState() {
        if (getActivity() instanceof DeletionHelperActivity) {
            DeletionHelperActivity activity = (DeletionHelperActivity) getActivity();
            activity.setIsEmptyState(true /* isEmptyState */);
        }
    }

    /** Clears out the selected apps and data from the device and closes the fragment. */
    protected void clearData() {
        long bytesFreed = getTotalFreeableSpace(COUNT_CHECKED_ONLY);
        if (mBytesToFree != UNSET && bytesFreed >= mBytesToFree) {
            setResultCode(Activity.RESULT_OK);
        }

        // This should be fine as long as there is only one extra deletion feature.
        // In the future, this should be done in an async queue in order to not
        // interfere with the simultaneous PackageDeletionTask.
        Activity activity = getActivity();
        if (mPhotoPreference != null && mPhotoPreference.isChecked()) {
            mPhotoVideoDeletion.clearFreeableData(activity);
        }
        if (mDownloadsPreference != null) {
            mDownloadsDeletion.clearFreeableData(activity);
        }
        if (mAppBackend != null) {
            mAppBackend.clearFreeableData(activity);
        }
    }

    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.next_button) {
            ConfirmDeletionDialog dialog =
                    ConfirmDeletionDialog.newInstance(getTotalFreeableSpace(COUNT_CHECKED_ONLY));
            // The 0 is a placeholder for an optional result code.
            dialog.setTargetFragment(this, 0);
            dialog.show(getFragmentManager(), ConfirmDeletionDialog.TAG);
            MetricsLogger.action(getContext(), MetricsEvent.ACTION_DELETION_HELPER_CLEAR);
        } else {
            MetricsLogger.action(getContext(), MetricsEvent.ACTION_DELETION_HELPER_CANCEL);
            getActivity().finish();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[],
                                           int[] grantResults) {
        if (requestCode == 0) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                mDownloadsDeletion.onResume();
                getLoaderManager().initLoader(DOWNLOADS_LOADER_ID, new Bundle(),
                        mDownloadsDeletion);
            }
        }
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater menuInflater) {
        Activity activity = getActivity();
        String mHelpUri = getResources().getString(R.string.help_uri_deletion_helper);
        if (mHelpUri != null && activity != null) {
            HelpUtils.prepareHelpMenuItem(activity, menu, mHelpUri, getClass().getName());
        }
    }

    @Override
    public View onCreateView(
            LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = super.onCreateView(inflater, container, savedInstanceState);
        return view;
    }

    @VisibleForTesting
    void setDownloadsDeletionType(DownloadsDeletionType downloadsDeletion) {
        mDownloadsDeletion = downloadsDeletion;
    }

    private void initializeButtons() {
        ButtonBarProvider activity = (ButtonBarProvider) getActivity();
        activity.getButtonBar().setVisibility(View.VISIBLE);

        mCancel = activity.getSkipButton();
        mCancel.setText(R.string.cancel);
        mCancel.setOnClickListener(this);
        mCancel.setVisibility(View.VISIBLE);

        mFree = activity.getNextButton();
        mFree.setText(R.string.storage_menu_free);
        mFree.setOnClickListener(this);
        mFree.setEnabled(false);
    }

    private void updateFreeButtonText() {
        Activity activity = getActivity();
        if (activity == null) {
            return;
        }
        mFree.setText(
                String.format(
                        activity.getString(R.string.deletion_helper_free_button),
                        Formatter.formatFileSize(
                                activity, getTotalFreeableSpace(COUNT_CHECKED_ONLY))));
    }

    private long getTotalFreeableSpace(boolean countUnchecked) {
        long freeableSpace = 0;
        if (mAppBackend != null) {
            freeableSpace += mAppBackend.getTotalAppsFreeableSpace(countUnchecked);
        }
        if (mPhotoPreference != null) {
            freeableSpace += mPhotoPreference.getFreeableBytes(countUnchecked);
        }
        if (mDownloadsPreference != null) {
            freeableSpace += mDownloadsDeletion.getFreeableBytes(countUnchecked);
        }
        return freeableSpace;
    }

    private void setResultCode(int result) {
        mResult = result;
        Activity activity = getActivity();
        if (activity != null) {
            activity.setResult(result);
        }
    }

    @VisibleForTesting
    protected int getResultCode() {
        return mResult;
    }
}