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

import com.android.internal.content.PackageMonitor;
import android.Manifest;
import android.app.ActivityThread;
import android.app.AlertDialog;
import android.app.AppOpsManager;
import android.app.Dialog;
import android.app.DialogFragment;
import android.app.Fragment;
import android.app.FragmentTransaction;
import android.content.Context;
import android.content.DialogInterface;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Looper;
import android.os.RemoteException;
import android.os.UserHandle;
import android.os.UserManager;
import android.preference.Preference;
import android.preference.PreferenceScreen;
import android.preference.SwitchPreference;
import android.util.ArrayMap;
import android.util.Log;
import android.util.SparseArray;

import java.util.List;
import java.util.Collections;

public class UsageAccessSettings extends SettingsPreferenceFragment implements
        Preference.OnPreferenceChangeListener {

    private static final String TAG = "UsageAccessSettings";
    private static final String BUNDLE_KEY_PROFILEID = "profileId";

    private static final String[] PM_USAGE_STATS_PERMISSION = new String[] {
            Manifest.permission.PACKAGE_USAGE_STATS
    };

    private static final int[] APP_OPS_OP_CODES = new int[] {
            AppOpsManager.OP_GET_USAGE_STATS
    };

    private static class PackageEntry implements Comparable<PackageEntry> {
        public PackageEntry(String packageName, UserHandle userHandle) {
            this.packageName = packageName;
            this.appOpMode = AppOpsManager.MODE_DEFAULT;
            this.userHandle = userHandle;
        }

        @Override
        public int compareTo(PackageEntry another) {
            return packageName.compareTo(another.packageName);
        }

        final String packageName;
        PackageInfo packageInfo;
        boolean permissionGranted;
        int appOpMode;
        UserHandle userHandle;

        SwitchPreference preference;
    }

    /**
     * Fetches the list of Apps that are requesting access to the UsageStats API and updates
     * the PreferenceScreen with the results when complete.
     */
    private class AppsRequestingAccessFetcher extends
            AsyncTask<Void, Void, SparseArray<ArrayMap<String, PackageEntry>>> {

        private final Context mContext;
        private final PackageManager mPackageManager;
        private final IPackageManager mIPackageManager;
        private final UserManager mUserManager;
        private final List<UserHandle> mProfiles;

        public AppsRequestingAccessFetcher(Context context) {
            mContext = context;
            mPackageManager = context.getPackageManager();
            mIPackageManager = ActivityThread.getPackageManager();
            mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
            mProfiles = mUserManager.getUserProfiles();
        }

        @Override
        protected SparseArray<ArrayMap<String, PackageEntry>> doInBackground(Void... params) {
            final String[] packages;
            SparseArray<ArrayMap<String, PackageEntry>> entries;
            try {
                packages = mIPackageManager.getAppOpPermissionPackages(
                        Manifest.permission.PACKAGE_USAGE_STATS);

                if (packages == null) {
                    // No packages are requesting permission to use the UsageStats API.
                    return null;
                }

                entries = new SparseArray<>();
                for (final UserHandle profile : mProfiles) {
                    final ArrayMap<String, PackageEntry> entriesForProfile = new ArrayMap<>();
                    final int profileId = profile.getIdentifier();
                    entries.put(profileId, entriesForProfile);
                    for (final String packageName : packages) {
                        final boolean isAvailable = mIPackageManager.isPackageAvailable(packageName,
                                profileId);
                        if (!shouldIgnorePackage(packageName) && isAvailable) {
                            final PackageEntry newEntry = new PackageEntry(packageName, profile);
                            entriesForProfile.put(packageName, newEntry);
                        }
                    }
                }
            } catch (RemoteException e) {
                Log.w(TAG, "PackageManager is dead. Can't get list of packages requesting "
                        + Manifest.permission.PACKAGE_USAGE_STATS);
                return null;
            }

             // Load the packages that have been granted the PACKAGE_USAGE_STATS permission.
            try {
                for (final UserHandle profile : mProfiles) {
                    final int profileId = profile.getIdentifier();
                    final ArrayMap<String, PackageEntry> entriesForProfile = entries.get(profileId);
                    if (entriesForProfile == null) {
                        continue;
                    }
                    final List<PackageInfo> packageInfos = mIPackageManager
                            .getPackagesHoldingPermissions(PM_USAGE_STATS_PERMISSION, 0, profileId)
                            .getList();
                    final int packageInfoCount = packageInfos != null ? packageInfos.size() : 0;
                    for (int i = 0; i < packageInfoCount; i++) {
                        final PackageInfo packageInfo = packageInfos.get(i);
                        final PackageEntry pe = entriesForProfile.get(packageInfo.packageName);
                        if (pe != null) {
                            pe.packageInfo = packageInfo;
                            pe.permissionGranted = true;
                        }
                    }
                }
            } catch (RemoteException e) {
                Log.w(TAG, "PackageManager is dead. Can't get list of packages granted "
                        + Manifest.permission.PACKAGE_USAGE_STATS);
                return null;
            }

            // Load the remaining packages that have requested but don't have the
            // PACKAGE_USAGE_STATS permission.
            for (final UserHandle profile : mProfiles) {
                final int profileId = profile.getIdentifier();
                final ArrayMap<String, PackageEntry> entriesForProfile = entries.get(profileId);
                if (entriesForProfile == null) {
                    continue;
                }
                int packageCount = entriesForProfile.size();
                for (int i = packageCount - 1; i >= 0; --i) {
                    final PackageEntry pe = entriesForProfile.valueAt(i);
                    if (pe.packageInfo == null) {
                        try {
                            pe.packageInfo = mIPackageManager.getPackageInfo(pe.packageName, 0,
                                    profileId);
                        } catch (RemoteException e) {
                            // This package doesn't exist. This may occur when an app is
                            // uninstalled for one user, but it is not removed from the system.
                            entriesForProfile.removeAt(i);
                        }
                    }
                }
            }

            // Find out which packages have been granted permission from AppOps.
            final List<AppOpsManager.PackageOps> packageOps = mAppOpsManager.getPackagesForOps(
                    APP_OPS_OP_CODES);
            final int packageOpsCount = packageOps != null ? packageOps.size() : 0;
            for (int i = 0; i < packageOpsCount; i++) {
                final AppOpsManager.PackageOps packageOp = packageOps.get(i);
                final int userId = UserHandle.getUserId(packageOp.getUid());
                if (!isThisUserAProfileOfCurrentUser(userId)) {
                    // This AppOp does not belong to any of this user's profiles.
                    continue;
                }

                final ArrayMap<String, PackageEntry> entriesForProfile = entries.get(userId);
                if (entriesForProfile == null) {
                    continue;
                }
                final PackageEntry pe = entriesForProfile.get(packageOp.getPackageName());
                if (pe == null) {
                    Log.w(TAG, "AppOp permission exists for package " + packageOp.getPackageName()
                            + " of user " + userId +
                            " but package doesn't exist or did not request UsageStats access");
                    continue;
                }

                if (packageOp.getOps().size() < 1) {
                    Log.w(TAG, "No AppOps permission exists for package "
                            + packageOp.getPackageName());
                    continue;
                }

                pe.appOpMode = packageOp.getOps().get(0).getMode();
            }

            return entries;
        }

        @Override
        protected void onPostExecute(SparseArray<ArrayMap<String, PackageEntry>> newEntries) {
            mLastFetcherTask = null;

            if (getActivity() == null) {
                // We must have finished the Activity while we were processing in the background.
                return;
            }

            if (newEntries == null) {
                mPackageEntryMap.clear();
                mPreferenceScreen.removeAll();
                return;
            }

            // Find the deleted entries and remove them from the PreferenceScreen.
            final int oldProfileCount = mPackageEntryMap.size();
            for (int profileIndex = 0; profileIndex < oldProfileCount; ++profileIndex) {
                final int profileId = mPackageEntryMap.keyAt(profileIndex);
                final ArrayMap<String, PackageEntry> oldEntriesForProfile = mPackageEntryMap
                        .valueAt(profileIndex);
                final int oldPackageCount = oldEntriesForProfile.size();

                final ArrayMap<String, PackageEntry> newEntriesForProfile = newEntries.get(
                        profileId);

                for (int i = 0; i < oldPackageCount; i++) {
                    final PackageEntry oldPackageEntry = oldEntriesForProfile.valueAt(i);

                    PackageEntry newPackageEntry = null;
                    if (newEntriesForProfile != null) {
                        newPackageEntry = newEntriesForProfile.get(oldPackageEntry.packageName);
                    }
                    if (newPackageEntry == null) {
                        // This package has been removed.
                        mPreferenceScreen.removePreference(oldPackageEntry.preference);
                    } else {
                        // This package already exists in the preference hierarchy, so reuse that
                        // Preference.
                        newPackageEntry.preference = oldPackageEntry.preference;
                    }
                }
            }

            // Now add new packages to the PreferenceScreen.
            final int newProfileCount = newEntries.size();
            for (int profileIndex = 0; profileIndex < newProfileCount; ++profileIndex) {
                final int profileId = newEntries.keyAt(profileIndex);
                final ArrayMap<String, PackageEntry> newEntriesForProfile = newEntries.get(
                        profileId);
                final int packageCount = newEntriesForProfile.size();
                for (int i = 0; i < packageCount; i++) {
                    final PackageEntry packageEntry = newEntriesForProfile.valueAt(i);
                    if (packageEntry.preference == null) {
                        packageEntry.preference = new SwitchPreference(mContext);
                        packageEntry.preference.setPersistent(false);
                        packageEntry.preference.setOnPreferenceChangeListener(
                                UsageAccessSettings.this);
                        mPreferenceScreen.addPreference(packageEntry.preference);
                    }
                    updatePreference(packageEntry);
                }
            }
            mPackageEntryMap.clear();
            mPackageEntryMap = newEntries;

            // Add/remove headers if necessary. If there are package entries only for one user and
            // that user is not the managed profile then do not show headers.
            if (mPackageEntryMap.size() == 1 &&
                    mPackageEntryMap.keyAt(0) == UserHandle.myUserId()) {
                for (int i = 0; i < mCategoryHeaders.length; ++i) {
                    if (mCategoryHeaders[i] != null) {
                        mPreferenceScreen.removePreference(mCategoryHeaders[i]);
                    }
                    mCategoryHeaders[i] = null;
                }
            } else {
                for (int i = 0; i < mCategoryHeaders.length; ++i) {
                    if (mCategoryHeaders[i] == null) {
                        final Preference preference = new Preference(mContext, null,
                                com.android.internal.R.attr.preferenceCategoryStyle, 0);
                        mCategoryHeaders[i] = preference;
                        preference.setTitle(mCategoryHeaderTitleResIds[i]);
                        preference.setEnabled(false);
                        mPreferenceScreen.addPreference(preference);
                    }
                }
            }

            // Sort preferences alphabetically within categories
            int order = 0;
            final int profileCount = mProfiles.size();
            for (int i = 0; i < profileCount; ++i) {
                Preference header = mCategoryHeaders[i];
                if (header != null) {
                    header.setOrder(order++);
                }
                ArrayMap<String, PackageEntry> entriesForProfile =
                        mPackageEntryMap.get(mProfiles.get(i).getIdentifier());
                if (entriesForProfile != null) {
                    List<PackageEntry> sortedEntries = Collections.list(
                            Collections.enumeration(entriesForProfile.values()));
                    Collections.sort(sortedEntries);
                    for (PackageEntry pe : sortedEntries) {
                        pe.preference.setOrder(order++);
                    }
                }
            }
        }

        private void updatePreference(PackageEntry pe) {
            final int profileId = pe.userHandle.getIdentifier();
            // Set something as default
            pe.preference.setEnabled(false);
            pe.preference.setTitle(pe.packageName);
            pe.preference.setIcon(mUserManager.getBadgedIconForUser(mPackageManager
                    .getDefaultActivityIcon(), pe.userHandle));
            try {
                // Try setting real title and icon
                final ApplicationInfo info = mIPackageManager.getApplicationInfo(pe.packageName,
                        0 /* no flags */, profileId);
                if (info != null) {
                    pe.preference.setEnabled(true);
                    pe.preference.setTitle(info.loadLabel(mPackageManager).toString());
                    pe.preference.setIcon(mUserManager.getBadgedIconForUser(info.loadIcon(
                            mPackageManager), pe.userHandle));
                }
            } catch (RemoteException e) {
                Log.w(TAG, "PackageManager is dead. Can't get app info for package " +
                        pe.packageName + " of user " + profileId);
                // Keep going to update other parts of the preference
            }

            pe.preference.setKey(pe.packageName);
            Bundle extra = pe.preference.getExtras();
            extra.putInt(BUNDLE_KEY_PROFILEID, profileId);

            boolean check = false;
            if (pe.appOpMode == AppOpsManager.MODE_ALLOWED) {
                check = true;
            } else if (pe.appOpMode == AppOpsManager.MODE_DEFAULT) {
                // If the default AppOps mode is set, then fall back to
                // whether the app has been granted permission by PackageManager.
                check = pe.permissionGranted;
            }

            if (check != pe.preference.isChecked()) {
                pe.preference.setChecked(check);
            }
        }

        private boolean isThisUserAProfileOfCurrentUser(final int userId) {
            final int profilesMax = mProfiles.size();
            for (int i = 0; i < profilesMax; ++i) {
                if (mProfiles.get(i).getIdentifier() == userId) {
                    return true;
                }
            }
            return false;
        }
    }

    static boolean shouldIgnorePackage(String packageName) {
        return packageName.equals("android") || packageName.equals("com.android.settings");
    }

    private AppsRequestingAccessFetcher mLastFetcherTask;
    SparseArray<ArrayMap<String, PackageEntry>> mPackageEntryMap = new SparseArray<>();
    AppOpsManager mAppOpsManager;
    PreferenceScreen mPreferenceScreen;
    private Preference[] mCategoryHeaders = new Preference[2];
    private static int[] mCategoryHeaderTitleResIds = new int[] {
        R.string.category_personal,
        R.string.category_work
    };

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        addPreferencesFromResource(R.xml.usage_access_settings);
        mPreferenceScreen = getPreferenceScreen();
        mPreferenceScreen.setOrderingAsAdded(false);
        mAppOpsManager = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE);
    }

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

        updateInterestedApps();
        mPackageMonitor.register(getActivity(), Looper.getMainLooper(), false);
    }

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

        mPackageMonitor.unregister();
        if (mLastFetcherTask != null) {
            mLastFetcherTask.cancel(true);
            mLastFetcherTask = null;
        }
    }

    private void updateInterestedApps() {
        if (mLastFetcherTask != null) {
            // Canceling can only fail for some obscure reason since mLastFetcherTask would be
            // null if the task has already completed. So we ignore the result of cancel and
            // spawn a new task to get fresh data. AsyncTask executes tasks serially anyways,
            // so we are safe from running two tasks at the same time.
            mLastFetcherTask.cancel(true);
        }

        mLastFetcherTask = new AppsRequestingAccessFetcher(getActivity());
        mLastFetcherTask.execute();
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        final String packageName = preference.getKey();
        final int profileId = preference.getExtras().getInt(BUNDLE_KEY_PROFILEID);
        final PackageEntry pe = getPackageEntry(packageName, profileId);
        if (pe == null) {
            Log.w(TAG, "Preference change event handling failed");
            return false;
        }

        if (!(newValue instanceof Boolean)) {
            Log.w(TAG, "Preference change event for package " + packageName + " of user " +
                    profileId + " had non boolean value of type " + newValue.getClass().getName());
            return false;
        }

        final int newMode = (Boolean) newValue ?
                AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_IGNORED;

        // Check if we need to do any work.
        if (pe.appOpMode != newMode) {
            if (newMode != AppOpsManager.MODE_ALLOWED) {
                // Turning off the setting has no warning.
                setNewMode(pe, newMode);
                return true;
            }

            // Turning on the setting has a Warning.
            FragmentTransaction ft = getChildFragmentManager().beginTransaction();
            Fragment prev = getChildFragmentManager().findFragmentByTag("warning");
            if (prev != null) {
                ft.remove(prev);
            }
            WarningDialogFragment.newInstance(pe).show(ft, "warning");
            return false;
        }
        return true;
    }

    void setNewMode(PackageEntry pe, int newMode) {
        mAppOpsManager.setMode(AppOpsManager.OP_GET_USAGE_STATS,
        pe.packageInfo.applicationInfo.uid, pe.packageName, newMode);
        pe.appOpMode = newMode;
    }

    void allowAccess(String packageName, int profileId) {
        final PackageEntry entry = getPackageEntry(packageName, profileId);
        if (entry == null) {
            Log.w(TAG, "Unable to give access");
            return;
        }

        setNewMode(entry, AppOpsManager.MODE_ALLOWED);
        entry.preference.setChecked(true);
    }

    private PackageEntry getPackageEntry(String packageName, int profileId) {
        ArrayMap<String, PackageEntry> entriesForProfile = mPackageEntryMap.get(profileId);
        if (entriesForProfile == null) {
            Log.w(TAG, "getPackageEntry fails for package " + packageName + " of user " +
                    profileId + ": user does not seem to be valid.");
            return null;
        }
        final PackageEntry entry = entriesForProfile.get(packageName);
        if (entry == null) {
            Log.w(TAG, "getPackageEntry fails for package " + packageName + " of user " +
                    profileId + ": package does not exist.");
        }
        return entry;
    }

    private final PackageMonitor mPackageMonitor = new PackageMonitor() {
        @Override
        public void onPackageAdded(String packageName, int uid) {
            updateInterestedApps();
        }

        @Override
        public void onPackageRemoved(String packageName, int uid) {
            updateInterestedApps();
        }
    };

    public static class WarningDialogFragment extends DialogFragment
            implements DialogInterface.OnClickListener {
        private static final String ARG_PACKAGE_NAME = "package";
        private static final String ARG_PROFILE_ID = "profileId";

        public static WarningDialogFragment newInstance(PackageEntry pe) {
            WarningDialogFragment dialog = new WarningDialogFragment();
            Bundle args = new Bundle();
            args.putString(ARG_PACKAGE_NAME, pe.packageName);
            args.putInt(ARG_PROFILE_ID, pe.userHandle.getIdentifier());
            dialog.setArguments(args);
            return dialog;
        }

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            return new AlertDialog.Builder(getActivity())
                    .setTitle(R.string.allow_usage_access_title)
                    .setMessage(R.string.allow_usage_access_message)
                    .setIconAttribute(android.R.attr.alertDialogIcon)
                    .setNegativeButton(R.string.cancel, this)
                    .setPositiveButton(android.R.string.ok, this)
                    .create();
        }

        @Override
        public void onClick(DialogInterface dialog, int which) {
            if (which == DialogInterface.BUTTON_POSITIVE) {
                ((UsageAccessSettings) getParentFragment()).allowAccess(
                        getArguments().getString(ARG_PACKAGE_NAME),
                        getArguments().getInt(ARG_PROFILE_ID));
            } else {
                dialog.cancel();
            }
        }
    }
}