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

import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.ArrayMap;
import android.util.Log;
import com.android.internal.app.ProcessStats;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public final class ProcStatsEntry implements Parcelable {
    private static final String TAG = "ProcStatsEntry";
    private static boolean DEBUG = ProcessStatsUi.DEBUG;

    final String mPackage;
    final int mUid;
    final String mName;
    final ArrayList<String> mPackages = new ArrayList<String>();
    final long mDuration;
    final long mAvgPss;
    final long mMaxPss;
    final long mAvgUss;
    final long mMaxUss;
    final long mWeight;

    String mBestTargetPackage;

    ArrayMap<String, ArrayList<Service>> mServices = new ArrayMap<String, ArrayList<Service>>(1);

    public ApplicationInfo mUiTargetApp;
    public String mUiLabel;
    public String mUiBaseLabel;
    public String mUiPackage;

    public ProcStatsEntry(ProcessStats.ProcessState proc, String packageName,
            ProcessStats.ProcessDataCollection tmpTotals, boolean useUss, boolean weightWithTime) {
        ProcessStats.computeProcessData(proc, tmpTotals, 0);
        mPackage = proc.mPackage;
        mUid = proc.mUid;
        mName = proc.mName;
        mPackages.add(packageName);
        mDuration = tmpTotals.totalTime;
        mAvgPss = tmpTotals.avgPss;
        mMaxPss = tmpTotals.maxPss;
        mAvgUss = tmpTotals.avgUss;
        mMaxUss = tmpTotals.maxUss;
        mWeight = (weightWithTime ? mDuration : 1) * (useUss ? mAvgUss : mAvgPss);
        if (DEBUG) Log.d(TAG, "New proc entry " + proc.mName + ": dur=" + mDuration
                + " avgpss=" + mAvgPss + " weight=" + mWeight);
    }

    public ProcStatsEntry(Parcel in) {
        mPackage = in.readString();
        mUid = in.readInt();
        mName = in.readString();
        in.readStringList(mPackages);
        mDuration = in.readLong();
        mAvgPss = in.readLong();
        mMaxPss = in.readLong();
        mAvgUss = in.readLong();
        mMaxUss = in.readLong();
        mWeight = in.readLong();
        mBestTargetPackage = in.readString();
        final int N = in.readInt();
        if (N > 0) {
            mServices.ensureCapacity(N);
            for (int i=0; i<N; i++) {
                String key = in.readString();
                ArrayList<Service> value = new ArrayList<Service>();
                in.readTypedList(value, Service.CREATOR);
                mServices.append(key, value);
            }
        }
    }

    public void addPackage(String packageName) {
        mPackages.add(packageName);
    }

    public void evaluateTargetPackage(PackageManager pm, ProcessStats stats,
            ProcessStats.ProcessDataCollection totals, Comparator<ProcStatsEntry> compare,
            boolean useUss, boolean weightWithTime) {
        mBestTargetPackage = null;
        if (mPackages.size() == 1) {
            if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": single pkg " + mPackages.get(0));
            mBestTargetPackage = mPackages.get(0);
        } else {
            // See if there is one significant package that was running here.
            ArrayList<ProcStatsEntry> subProcs = new ArrayList<ProcStatsEntry>();
            for (int ipkg=0; ipkg<mPackages.size(); ipkg++) {
                ProcessStats.PackageState pkgState = stats.mPackages.get(mPackages.get(ipkg), mUid);
                if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ", pkg "
                        + mPackages.get(ipkg) + ":");
                if (pkgState == null) {
                    Log.w(TAG, "No package state found for " + mPackages.get(ipkg) + "/"
                            + mUid + " in process " + mName);
                    continue;
                }
                ProcessStats.ProcessState pkgProc = pkgState.mProcesses.get(mName);
                if (pkgProc == null) {
                    Log.w(TAG, "No process " + mName + " found in package state "
                            + mPackages.get(ipkg) + "/" + mUid);
                    continue;
                }
                subProcs.add(new ProcStatsEntry(pkgProc, pkgState.mPackageName, totals, useUss,
                        weightWithTime));
            }
            if (subProcs.size() > 1) {
                Collections.sort(subProcs, compare);
                if (subProcs.get(0).mWeight > (subProcs.get(1).mWeight*3)) {
                    if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": best pkg "
                            + subProcs.get(0).mPackage + " weight " + subProcs.get(0).mWeight
                            + " better than " + subProcs.get(1).mPackage
                            + " weight " + subProcs.get(1).mWeight);
                    mBestTargetPackage = subProcs.get(0).mPackage;
                    return;
                }
                // Couldn't find one that is best by weight, let's decide on best another
                // way: the one that has the longest running service, accounts for at least
                // half of the maximum weight, and has specified an explicit app icon.
                long maxWeight = subProcs.get(0).mWeight;
                long bestRunTime = -1;
                for (int i=0; i<subProcs.size(); i++) {
                    if (subProcs.get(i).mWeight < (maxWeight/2)) {
                        if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                + subProcs.get(i).mPackage + " weight " + subProcs.get(i).mWeight
                                + " too small");
                        continue;
                    }
                    try {
                        ApplicationInfo ai = pm.getApplicationInfo(subProcs.get(i).mPackage, 0);
                        if (ai.icon == 0) {
                            if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                    + subProcs.get(i).mPackage + " has no icon");
                            continue;
                        }
                    } catch (PackageManager.NameNotFoundException e) {
                        if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                + subProcs.get(i).mPackage + " failed finding app info");
                        continue;
                    }
                    ArrayList<Service> subProcServices = null;
                    for (int isp=0, NSP=mServices.size(); isp<NSP; isp++) {
                        ArrayList<Service> subServices = mServices.valueAt(isp);
                        if (subServices.get(0).mPackage.equals(subProcs.get(i).mPackage)) {
                            subProcServices = subServices;
                            break;
                        }
                    }
                    long thisRunTime = 0;
                    if (subProcServices != null) {
                        for (int iss=0, NSS=subProcServices.size(); iss<NSS; iss++) {
                            Service service = subProcServices.get(iss);
                            if (service.mDuration > thisRunTime) {
                                if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                        + subProcs.get(i).mPackage + " service " + service.mName
                                        + " run time is " + service.mDuration);
                                thisRunTime = service.mDuration;
                                break;
                            }
                        }
                    }
                    if (thisRunTime > bestRunTime) {
                        if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                + subProcs.get(i).mPackage + " new best run time " + thisRunTime);
                        mBestTargetPackage = subProcs.get(i).mPackage;
                        bestRunTime = thisRunTime;
                    } else {
                        if (DEBUG) Log.d(TAG, "Eval pkg of " + mName + ": pkg "
                                + subProcs.get(i).mPackage + " run time " + thisRunTime
                                + " not as good as last " + bestRunTime);
                    }
                }
            } else if (subProcs.size() == 1) {
                mBestTargetPackage = subProcs.get(0).mPackage;
            }
        }
    }

    public void retrieveUiData(PackageManager pm) {
        mUiTargetApp = null;
        mUiLabel = mUiBaseLabel = mName;
        mUiPackage = mBestTargetPackage;
        if (mUiPackage != null) {
            // Only one app associated with this process.
            try {
                mUiTargetApp = pm.getApplicationInfo(mUiPackage,
                        PackageManager.GET_DISABLED_COMPONENTS |
                        PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS |
                        PackageManager.GET_UNINSTALLED_PACKAGES);
                String name = mUiBaseLabel = mUiTargetApp.loadLabel(pm).toString();
                if (mName.equals(mUiPackage)) {
                    mUiLabel = name;
                } else {
                    if (mName.startsWith(mUiPackage)) {
                        int off = mUiPackage.length();
                        if (mName.length() > off) {
                            off++;
                        }
                        mUiLabel = name + " (" + mName.substring(off) + ")";
                    } else {
                        mUiLabel = name + " (" + mName + ")";
                    }
                }
            } catch (PackageManager.NameNotFoundException e) {
            }
        }
        if (mUiTargetApp == null) {
            String[] packages = pm.getPackagesForUid(mUid);
            if (packages != null) {
                for (String curPkg : packages) {
                    try {
                        final PackageInfo pi = pm.getPackageInfo(curPkg,
                                PackageManager.GET_DISABLED_COMPONENTS |
                                PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS |
                                PackageManager.GET_UNINSTALLED_PACKAGES);
                        if (pi.sharedUserLabel != 0) {
                            mUiTargetApp = pi.applicationInfo;
                            final CharSequence nm = pm.getText(curPkg,
                                    pi.sharedUserLabel, pi.applicationInfo);
                            if (nm != null) {
                                mUiBaseLabel = nm.toString();
                                mUiLabel = mUiBaseLabel + " (" + mName + ")";
                            } else {
                                mUiBaseLabel = mUiTargetApp.loadLabel(pm).toString();
                                mUiLabel = mUiBaseLabel + " (" + mName + ")";
                            }
                            break;
                        }
                    } catch (PackageManager.NameNotFoundException e) {
                    }
                }
            } else {
                // no current packages for this uid, typically because of uninstall
                Log.i(TAG, "No package for uid " + mUid);
            }
        }
    }

    public void addService(ProcessStats.ServiceState svc) {
        ArrayList<Service> services = mServices.get(svc.mPackage);
        if (services == null) {
            services = new ArrayList<Service>();
            mServices.put(svc.mPackage, services);
        }
        services.add(new Service(svc));
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(mPackage);
        dest.writeInt(mUid);
        dest.writeString(mName);
        dest.writeStringList(mPackages);
        dest.writeLong(mDuration);
        dest.writeLong(mAvgPss);
        dest.writeLong(mMaxPss);
        dest.writeLong(mAvgUss);
        dest.writeLong(mMaxUss);
        dest.writeLong(mWeight);
        dest.writeString(mBestTargetPackage);
        final int N = mServices.size();
        dest.writeInt(N);
        for (int i=0; i<N; i++) {
            dest.writeString(mServices.keyAt(i));
            dest.writeTypedList(mServices.valueAt(i));
        }
    }

    public static final Parcelable.Creator<ProcStatsEntry> CREATOR
            = new Parcelable.Creator<ProcStatsEntry>() {
        public ProcStatsEntry createFromParcel(Parcel in) {
            return new ProcStatsEntry(in);
        }

        public ProcStatsEntry[] newArray(int size) {
            return new ProcStatsEntry[size];
        }
    };

    public static final class Service implements Parcelable {
        final String mPackage;
        final String mName;
        final String mProcess;
        final long mDuration;

        public Service(ProcessStats.ServiceState service) {
            mPackage = service.mPackage;
            mName = service.mName;
            mProcess = service.mProcessName;
            mDuration = ProcessStats.dumpSingleServiceTime(null, null, service,
                    ProcessStats.ServiceState.SERVICE_RUN,
                    ProcessStats.STATE_NOTHING, 0, 0);
        }

        public Service(Parcel in) {
            mPackage = in.readString();
            mName = in.readString();
            mProcess = in.readString();
            mDuration = in.readLong();
        }

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeString(mPackage);
            dest.writeString(mName);
            dest.writeString(mProcess);
            dest.writeLong(mDuration);
        }

        public static final Parcelable.Creator<Service> CREATOR
                = new Parcelable.Creator<Service>() {
            public Service createFromParcel(Parcel in) {
                return new Service(in);
            }

            public Service[] newArray(int size) {
                return new Service[size];
            }
        };
    }
}