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

import java.io.InputStream;
import java.io.IOException;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

public class RawBatteryStats {
    /**
     * The factory objects for the records. Initialized in the static block.
     */
    private static HashMap<String,RecordFactory> sFactories
            = new HashMap<String,RecordFactory>();

    /**
     * The Record objects that have been parsed.
     */
    private ArrayList<Record> mRecords = new ArrayList<Record>();

    /**
     * The Record objects that have been parsed, indexed by type.
     *
     * Don't use this before {@link #indexRecords()} has been called.
     */
    private ImmutableMap<String,ImmutableList<Record>> mRecordsByType;

    /**
     * The attribution keys for which we have data (corresponding to UIDs we've seen).
     * <p>
     * Does not include the synthetic apps.
     * <p>
     * Don't use this before {@link #indexRecords()} has been called.
     */
    private ImmutableSet<AttributionKey> mApps;

    /**
     * The warnings that have been issued during parsing.
     */
    private ArrayList<Warning> mWarnings = new ArrayList<Warning>();

    /**
     * The version of the BatteryStats dumpsys that we are using.  This value
     * is set to -1 initially, and then when parsing the (hopefully) first
     * line, 'vers', it is set to the correct version.
     */
    private int mDumpsysVersion = -1;

    /**
     * Enum used in the Line annotation to mark whether a field is expected to be
     * system-wide or scoped to an app.
     */
    public enum Scope {
        SYSTEM,
        UID
    }

    /**
     * Enum used to indicated the expected number of results.
     */
    public enum Count {
        SINGLE,
        MULTIPLE
    }

    /**
     * Annotates classes that represent a line of CSV in the batterystats CSV
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @interface Line {
        String tag();
        Scope scope();
        Count count();
    }

    /**
     * Annotates fields that should be parsed automatically from CSV
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    @interface Field {
        /**
         * The "column" of this field in the most recent version of the CSV.
         * When parsing old versions, fields that were added will be automatically
         * removed and the indices will be fixed up.
         *
         * The header fields (version, uid, category, type) will be automatically
         * handled for the base Line type.  The index 0 should start after those.
         */
        int index();

        /**
         * First version that this field appears in.
         */
        int added() default 0;
    }

    /**
     * Each line in the BatteryStats CSV is tagged with a category, that says
     * which of the time collection modes was used for the data.
     */
    public enum Category {
        INFO("i"),
        LAST("l"),
        UNPLUGGED("u"),
        CURRENT("c");

        public final String tag;

        Category(String tag) {
            this.tag = tag;
        }
    }

    /**
     * Base class for all lines in a batterystats CSV file.
     */
    public static class Record {
        /**
         * Whether all of the fields for the indicated version of this record
         * have been filled in.
         */
        public boolean complete;


        @Field(index=-4)
        public int lineVersion;

        @Field(index=-3)
        public int uid;

        @Field(index=-2)
        public Category category;

        @Field(index=-1)
        public String lineType;
    }

    @Line(tag="bt", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class Battery extends Record {
        // If which != STATS_SINCE_CHARGED, the csv will be "N/A" and we will get
        // a parsing warning.  Nobody uses anything other than STATS_SINCE_CHARGED.
        @Field(index=0)
        public int startCount;

        @Field(index=1)
        public long whichBatteryRealtimeMs;

        @Field(index=2)
        public long whichBatteryUptimeMs;

        @Field(index=3)
        public long totalRealtimeMs;

        @Field(index=4)
        public long totalUptimeMs;

        @Field(index=5)
        public long getStartClockTimeMs;

        @Field(index=6)
        public long whichBatteryScreenOffRealtimeMs;

        @Field(index=7)
        public long whichBatteryScreenOffUptimeMs;

        @Field(index=8)
        public long estimatedBatteryCapacityMah;

        @Field(index=9)
        public long minLearnedBatteryCapacityMah;

        @Field(index=10)
        public long maxLearnedBatteryCapacityMah;

        @Field(index=11)
        public long screenDozeTimeMs;
    }

    @Line(tag="gn", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class GlobalNetwork extends Record {
        @Field(index=0)
        public long mobileRxTotalBytes;

        @Field(index=1)
        public long mobileTxTotalBytes;

        @Field(index=2)
        public long wifiRxTotalBytes;

        @Field(index=3)
        public long wifiTxTotalBytes;

        @Field(index=4)
        public long mobileRxTotalPackets;

        @Field(index=5)
        public long mobileTxTotalPackets;

        @Field(index=6)
        public long wifiRxTotalPackets;

        @Field(index=7)
        public long wifiTxTotalPackets;

        @Field(index=8)
        public long btRxTotalBytes;

        @Field(index=9)
        public long btTxTotalBytes;
    }

    @Line(tag="gmcd", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class GlobalModemController extends Record {
        @Field(index=0)
        public long idleMs;

        @Field(index=1)
        public long rxTimeMs;

        @Field(index=2)
        public long powerMaMs;

        @Field(index=3)
        public long[] txTimeMs;
    }

    @Line(tag="m", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class Misc extends Record {
        @Field(index=0)
        public long screenOnTimeMs;

        @Field(index=1)
        public long phoneOnTimeMs;

        @Field(index=2)
        public long fullWakeLockTimeTotalMs;

        @Field(index=3)
        public long partialWakeLockTimeTotalMs;

        @Field(index=4)
        public long mobileRadioActiveTimeMs;

        @Field(index=5)
        public long mobileRadioActiveAdjustedTimeMs;

        @Field(index=6)
        public long interactiveTimeMs;

        @Field(index=7)
        public long powerSaveModeEnabledTimeMs;

        @Field(index=8)
        public int connectivityChangeCount;

        @Field(index=9)
        public long deepDeviceIdleModeTimeMs;

        @Field(index=10)
        public long deepDeviceIdleModeCount;

        @Field(index=11)
        public long deepDeviceIdlingTimeMs;

        @Field(index=12)
        public long deepDeviceIdlingCount;

        @Field(index=13)
        public long mobileRadioActiveCount;

        @Field(index=14)
        public long mobileRadioActiveUnknownTimeMs;

        @Field(index=15)
        public long lightDeviceIdleModeTimeMs;

        @Field(index=16)
        public long lightDeviceIdleModeCount;

        @Field(index=17)
        public long lightDeviceIdlingTimeMs;

        @Field(index=18)
        public long lightDeviceIdlingCount;

        @Field(index=19)
        public long lightLongestDeviceIdleModeTimeMs;

        @Field(index=20)
        public long deepLongestDeviceIdleModeTimeMs;
    }

    @Line(tag="nt", scope=Scope.UID, count=Count.SINGLE)
    public static class Network extends Record {
        @Field(index=0)
        public long mobileRxBytes;

        @Field(index=1)
        public long mobileTxBytes;

        @Field(index=2)
        public long wifiRxBytes;

        @Field(index=3)
        public long wifiTxBytes;

        @Field(index=4)
        public long mobileRxPackets;

        @Field(index=5)
        public long mobileTxPackets;

        @Field(index=6)
        public long wifiRxPackets;

        @Field(index=7)
        public long wifiTxPackets;

        // This is microseconds, because... batterystats.
        @Field(index=8)
        public long mobileRadioActiveTimeUs;

        @Field(index=9)
        public long mobileRadioActiveCount;

        @Field(index=10)
        public long btRxBytes;

        @Field(index=11)
        public long btTxBytes;

        @Field(index=12)
        public long mobileWakeupCount;

        @Field(index=13)
        public long wifiWakeupCount;

        @Field(index=14)
        public long mobileBgRxBytes;

        @Field(index=15)
        public long mobileBgTxBytes;

        @Field(index=16)
        public long wifiBgRxBytes;

        @Field(index=17)
        public long wifiBgTxBytes;

        @Field(index=18)
        public long mobileBgRxPackets;

        @Field(index=19)
        public long mobileBgTxPackets;

        @Field(index=20)
        public long wifiBgRxPackets;

        @Field(index=21)
        public long wifiBgTxPackets;
    }

    @Line(tag="sgt", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class SignalStrengthTime extends Record {
        @Field(index=0)
        public long[] phoneSignalStrengthTimeMs;
    }

    @Line(tag="sst", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class SignalScanningTime extends Record {
        @Field(index=0)
        public long phoneSignalScanningTimeMs;
    }

    @Line(tag="uid", scope=Scope.UID, count=Count.MULTIPLE)
    public static class Uid extends Record {
        @Field(index=0)
        public int uidKey;

        @Field(index=1)
        public String pkg;
    }

    @Line(tag="vers", scope=Scope.SYSTEM, count=Count.SINGLE)
    public static class Version extends Record {
        @Field(index=0)
        public int dumpsysVersion;

        @Field(index=1)
        public int parcelVersion;

        @Field(index=2)
        public String startPlatformVersion;

        @Field(index=3)
        public String endPlatformVersion;
    }

    /**
     * Codes for the warnings to classify warnings without parsing them.
     */
    public enum WarningId {
        /**
         * A row didn't have enough fields to match any records and let us extract
         * a line type.
         */
        TOO_FEW_FIELDS_FOR_LINE_TYPE,

        /**
         * We couldn't find a Record for the given line type.
         */
        NO_MATCHING_LINE_TYPE,

        /**
         * Couldn't set the value of a field. Usually this is because the
         * contents of a numeric type couldn't be parsed.
         */
        BAD_FIELD_TYPE,

        /**
         * There were extra field values in the input text.
         */
        TOO_MANY_FIELDS,

        /**
         * There were fields that we were expecting (for this version
         * of the dumpsys) that weren't provided in the CSV data.
         */
        NOT_ENOUGH_FIELDS,

        /**
         * The dumpsys version in the 'vers' CSV line couldn't be parsed.
         */
        BAD_DUMPSYS_VERSION
    }

    /**
     * A non-fatal problem detected during parsing.
     */
    public static class Warning {
        private int mLineNumber;
        private WarningId mId;
        private ArrayList<String> mFields;
        private String mMessage;
        private String[] mExtras;

        public Warning(int lineNumber, WarningId id, ArrayList<String> fields, String message,
                String[] extras) {
            mLineNumber = lineNumber;
            mId = id;
            mFields = fields;
            mMessage = message;
            mExtras = extras;
        }

        public int getLineNumber() {
            return mLineNumber;
        }

        public ArrayList<String> getFields() {
            return mFields;
        }

        public String getMessage() {
            return mMessage;
        }

        public String[] getExtras() {
            return mExtras;
        }
    }

    /**
     * Base class for classes to set fields on Record objects via reflection.
     */
    private abstract static class FieldSetter {
        private int mIndex;
        private int mAdded;
        protected java.lang.reflect.Field mField;

        FieldSetter(int index, int added, java.lang.reflect.Field field) {
            mIndex = index;
            mAdded = added;
            mField = field;
        }

        String getName() {
            return mField.getName();
        }

        int getIndex() {
            return mIndex;
        }

        int getAdded() {
            return mAdded;
        }

        boolean isArray() {
            return mField.getType().isArray();
        }

        abstract void setField(int lineNumber, Record object, String value) throws ParseException;
        abstract void setArray(int lineNumber, Record object, ArrayList<String> values,
                int startIndex, int endIndex) throws ParseException;

        @Override
        public String toString() {
            final String className = getClass().getName();
            int startIndex = Math.max(className.lastIndexOf('.'), className.lastIndexOf('$'));
            if (startIndex < 0) {
                startIndex = 0;
            } else {
                startIndex++;
            }
            return className.substring(startIndex) + "(index=" + mIndex + " added=" + mAdded
                    + " field=" + mField.getName()
                    + " type=" + mField.getType().getSimpleName()
                    + ")";
        }
    }

    /**
     * Sets int fields on Record objects using reflection.
     */
    private static class IntFieldSetter extends FieldSetter {
        IntFieldSetter(int index, int added, java.lang.reflect.Field field) {
            super(index, added, field);
        }

        void setField(int lineNumber, Record object, String value) throws ParseException {
            try {
                mField.setInt(object, Integer.parseInt(value.trim()));
            } catch (NumberFormatException ex) {
                throw new ParseException(lineNumber, "can't parse as integer: " + value);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }

        void setArray(int lineNumber, Record object, ArrayList<String> values,
                int startIndex, int endIndex) throws ParseException {
            try {
                final int[] array = new int[endIndex-startIndex];
                for (int i=startIndex; i<endIndex; i++) {
                    final String value = values.get(startIndex+i);
                    try {
                        array[i] = Integer.parseInt(value.trim());
                    } catch (NumberFormatException ex) {
                        throw new ParseException(lineNumber, "can't parse field "
                                + i + " as integer: " + value);
                    }
                }
                mField.set(object, array);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    /**
     * Sets long fields on Record objects using reflection.
     */
    private static class LongFieldSetter extends FieldSetter {
        LongFieldSetter(int index, int added, java.lang.reflect.Field field) {
            super(index, added, field);
        }

        void setField(int lineNumber, Record object, String value) throws ParseException {
            try {
                mField.setLong(object, Long.parseLong(value.trim()));
            } catch (NumberFormatException ex) {
                throw new ParseException(lineNumber, "can't parse as long: " + value);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }

        void setArray(int lineNumber, Record object, ArrayList<String> values,
                int startIndex, int endIndex) throws ParseException {
            try {
                final long[] array = new long[endIndex-startIndex];
                for (int i=0; i<(endIndex-startIndex); i++) {
                    final String value = values.get(startIndex+i);
                    try {
                        array[i] = Long.parseLong(value.trim());
                    } catch (NumberFormatException ex) {
                        throw new ParseException(lineNumber, "can't parse field "
                                + i + " as long: " + value);
                    }
                }
                mField.set(object, array);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    /**
     * Sets String fields on Record objects using reflection.
     */
    private static class StringFieldSetter extends FieldSetter {
        StringFieldSetter(int index, int added, java.lang.reflect.Field field) {
            super(index, added, field);
        }

        void setField(int lineNumber, Record object, String value) throws ParseException {
            try {
                mField.set(object, value);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }

        void setArray(int lineNumber, Record object, ArrayList<String> values,
                int startIndex, int endIndex) throws ParseException {
            try {
                final String[] array = new String[endIndex-startIndex];
                for (int i=0; i<(endIndex-startIndex); i++) {
                    array[i] = values.get(startIndex+1);
                }
                mField.set(object, array);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    /**
     * Sets enum fields on Record objects using reflection.
     *
     * To be parsed automatically, enums must have a public final String tag
     * field, which is the string that will appear in the csv for that enum value.
     */
    private static class EnumFieldSetter extends FieldSetter {
        private final HashMap<String,Enum> mTags = new HashMap<String,Enum>();

        EnumFieldSetter(int index, int added, java.lang.reflect.Field field) {
            super(index, added, field);

            // Build the mapping of tags to values.
            final Class<?> fieldType = field.getType();

            java.lang.reflect.Field tagField = null;
            try {
                tagField = fieldType.getField("tag");
            } catch (NoSuchFieldException ex) {
                throw new RuntimeException("Missing tag field."
                        + " To be parsed automatically, enums must have"
                        + " a String field called tag.  Enum class: " + fieldType.getName()
                        + " Containing class: " + field.getDeclaringClass().getName()
                        + " Field: " + field.getName());

            }
            if (!String.class.equals(tagField.getType())) {
                throw new RuntimeException("Tag field is not string."
                        + " To be parsed automatically, enums must have"
                        + " a String field called tag.  Enum class: " + fieldType.getName()
                        + " Containing class: " + field.getDeclaringClass().getName()
                        + " Field: " + field.getName()
                        + " Tag field type: " + tagField.getType().getName());
            }

            for (final Object enumValue: fieldType.getEnumConstants()) {
                String tag = null;
                try {
                    tag = (String)tagField.get(enumValue);
                } catch (IllegalAccessException | IllegalArgumentException
                        | ExceptionInInitializerError ex) {
                    throw new RuntimeException(ex);
                }
                mTags.put(tag, (Enum)enumValue);
            }
        }

        void setField(int lineNumber, Record object, String value) throws ParseException {
            final Enum enumValue = mTags.get(value);
            if (enumValue == null) {
                throw new ParseException(lineNumber, "Could not find enum for field "
                        + getName() + " for tag: " + value);
            }
            try {
                mField.set(object, enumValue);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }

        void setArray(int lineNumber, Record object, ArrayList<String> values,
                int startIndex, int endIndex) throws ParseException {
            try {
                final Object array = Array.newInstance(mField.getType().getComponentType(),
                        endIndex-startIndex);
                for (int i=0; i<(endIndex-startIndex); i++) {
                    final String value = values.get(startIndex+i);
                    final Enum enumValue = mTags.get(value);
                    if (enumValue == null) {
                        throw new ParseException(lineNumber, "Could not find enum for field "
                                + getName() + " for tag: " + value);
                    }
                    Array.set(array, i, enumValue);
                }
                mField.set(object, array);
            } catch (IllegalAccessException | IllegalArgumentException
                    | ExceptionInInitializerError ex) {
                throw new RuntimeException(ex);
            }
        }
    }

    /**
     * Factory for the record classes.  Uses reflection to create
     * the fields.
     */
    private static class RecordFactory {
        private String mTag;
        private Class<? extends Record> mSubclass;
        private ArrayList<FieldSetter> mFieldSetters;

        RecordFactory(String tag, Class<? extends Record> subclass,
                ArrayList<FieldSetter> fieldSetters) {
            mTag = tag;
            mSubclass = subclass;
            mFieldSetters = fieldSetters;
        }

        /**
         * Create an object of one of the subclasses of Record, and fill
         * in the fields marked with the Field annotation.
         *
         * @return a new Record with the fields filled in. If there are missing
         *      fields, the {@link Record.complete} field will be set to false.
         */
        Record create(RawBatteryStats bs, int dumpsysVersion, int lineNumber,
                ArrayList<String> fieldValues) {
            final boolean debug = false;
            Record record = null;
            try {
                if (debug) {
                    System.err.println("Creating object: " + mSubclass.getSimpleName());
                }
                record = mSubclass.newInstance();
            } catch (IllegalAccessException | InstantiationException
                    | ExceptionInInitializerError | SecurityException ex) {
                throw new RuntimeException("Exception creating " + mSubclass.getName()
                        + " for '" + mTag + "' record.", ex);
            }
            record.complete = true;
            int fieldIndex = 0;
            int setterIndex = 0;
            while (fieldIndex < fieldValues.size() && setterIndex < mFieldSetters.size()) {
                final FieldSetter setter = mFieldSetters.get(setterIndex);

                if (dumpsysVersion >= 0 && dumpsysVersion < setter.getAdded()) {
                    // The version being parsed doesn't have the field for this setter,
                    // so skip the setter but not the field.
                    setterIndex++;
                    continue;
                }

                final String value = fieldValues.get(fieldIndex);
                try {
                    if (debug) {
                        System.err.println("   setting field " + setter + " to: " + value);
                    }
                    if (setter.isArray()) {
                        setter.setArray(lineNumber, record, fieldValues,
                                fieldIndex, fieldValues.size());
                        // The rest of the fields have been consumed.
                        fieldIndex = fieldValues.size();
                        setterIndex = mFieldSetters.size();
                        break;
                    } else {
                        setter.setField(lineNumber, record, value);
                    }
                } catch (ParseException ex) {
                    bs.addWarning(lineNumber, WarningId.BAD_FIELD_TYPE, fieldValues,
                            ex.getMessage(), mTag, value);
                    record.complete = false;
                }

                fieldIndex++;
                setterIndex++;
            }

            // If there are extra fields, this record is complete, there are just
            // extra values, so we issue a warning but don't mark it incomplete.
            if (fieldIndex < fieldValues.size()) {
                bs.addWarning(lineNumber, WarningId.TOO_MANY_FIELDS, fieldValues,
                        "Line '" + mTag + "' has extra fields.",
                        mTag, Integer.toString(fieldIndex), Integer.toString(fieldValues.size()));
                if (debug) {
                    for (int i=0; i<mFieldSetters.size(); i++) {
                        System.err.println("    setter: [" + i + "] " + mFieldSetters.get(i));
                    }
                }
            }

            // If we have any fields that are missing, add a warning and return null.
            for (; setterIndex < mFieldSetters.size(); setterIndex++) {
                final FieldSetter setter = mFieldSetters.get(setterIndex);
                if (dumpsysVersion >= 0 && dumpsysVersion >= setter.getAdded()) {
                    bs.addWarning(lineNumber, WarningId.NOT_ENOUGH_FIELDS, fieldValues,
                            "Line '" + mTag + "' missing field: index=" + setterIndex
                                + " name=" + setter.getName(),
                            mTag, Integer.toString(setterIndex));
                    record.complete = false;
                }
            }

            return record;
        }
    }

    /**
     * Parse the input stream and return a RawBatteryStats object.
     */
    public static RawBatteryStats parse(InputStream input) throws ParseException, IOException {
        final RawBatteryStats result = new RawBatteryStats();
        result.parseImpl(input);
        return result;
    }

    /**
     * Get a record.
     * <p>
     * If multiple of that record are found, returns the first one.  There will already
     * have been a warning recorded if the count annotation did not match what was in the
     * csv.
     * <p>
     * Returns null if there are no records of that type.
     */
    public <T extends Record> T getSingle(Class<T> cl) {
        final List<Record> list = mRecordsByType.get(cl.getName());
        if (list == null) {
            return null;
        }
        // Notes:
        //   - List can never be empty because the list itself wouldn't have been added.
        //   - Cast is safe because list was populated based on class name (let's assume
        //     there's only one class loader involved here).
        return (T)list.get(0);
    }

    /**
     * Get a record.
     * <p>
     * If multiple of that record are found, returns the first one that matches that uid.
     * <p>
     * Returns null if there are no records of that type that match the given uid.
     */
    public <T extends Record> T getSingle(Class<T> cl, int uid) {
        final List<Record> list = mRecordsByType.get(cl.getName());
        if (list == null) {
            return null;
        }
        for (final Record record: list) {
            if (record.uid == uid) {
                // Cast is safe because list was populated based on class name (let's assume
                // there's only one class loader involved here).
                return (T)record;
            }
        }
        return null;
    }

    /**
     * Get all the records of the given type.
     */
    public <T extends Record> List<T> getMultiple(Class<T> cl) {
        final List<Record> list = mRecordsByType.get(cl.getName());
        if (list == null) {
            return ImmutableList.<T>of();
        }
        // Cast is safe because list was populated based on class name (let's assume
        // there's only one class loader involved here).
        return ImmutableList.copyOf((List<T>)list);
    }

    /**
     * Get the UIDs that are covered by this batterystats dump.
     */
    public Set<AttributionKey> getApps() {
        return mApps;
    }

    /**
     * No public constructor. Use {@link #parse}.
     */
    private RawBatteryStats() {
    }

    /**
     * Get the list of Record objects that were parsed from the csv.
     */
    public List<Record> getRecords() {
        return mRecords;
    }

    /**
     * Gets the warnings that were encountered during parsing.
     */
    public List<Warning> getWarnings() {
        return mWarnings;
    }

    /**
     * Implementation of the csv parsing.
     */
    private void parseImpl(InputStream input) throws ParseException, IOException {
        // Parse the csv
        CsvParser.parse(input, new CsvParser.LineProcessor() {
                    @Override
                    public void onLine(int lineNumber, ArrayList<String> fields)
                            throws ParseException {
                        handleCsvLine(lineNumber, fields);
                    }
                });

        // Gather the records by class name for the getSingle() and getMultiple() functions.
        indexRecords();

        // Gather the uids from all the places UIDs come from, for getApps().
        indexApps();
    }

    /**
     * Handle a line of CSV input, creating the right Record object.
     */
    private void handleCsvLine(int lineNumber, ArrayList<String> fields) throws ParseException {
        // The standard rows all have the 4 core fields. Anything less isn't what we're
        // looking for.
        if (fields.size() <= 4) {
            addWarning(lineNumber, WarningId.TOO_FEW_FIELDS_FOR_LINE_TYPE, fields,
                    "Line with too few fields (" + fields.size() + ")",
                    Integer.toString(fields.size()));
            return;
        }

        final String lineType = fields.get(3);

        // Handle the vers line specially, because we need the version number
        // to make the rest of the machinery work.
        if ("vers".equals(lineType)) {
            final String versionText = fields.get(4);
            try {
                mDumpsysVersion = Integer.parseInt(versionText);
            } catch (NumberFormatException ex) {
                addWarning(lineNumber, WarningId.BAD_DUMPSYS_VERSION, fields,
                        "Couldn't parse dumpsys version number: '" + versionText,
                        versionText);
            }
        }

        // Find the right factory.
        final RecordFactory factory = sFactories.get(lineType);
        if (factory == null) {
            addWarning(lineNumber, WarningId.NO_MATCHING_LINE_TYPE, fields,
                    "No Record for line type '" + lineType + "'",
                    lineType);
            return;
        }

        // Create the record.
        final Record record = factory.create(this, mDumpsysVersion, lineNumber, fields);
        mRecords.add(record);
    }

    /**
     * Add to the list of warnings.
     */
    private void addWarning(int lineNumber, WarningId id,
            ArrayList<String> fields, String message, String... extras) {
        mWarnings.add(new Warning(lineNumber, id, fields, message, extras));
        final boolean debug = false;
        if (debug) {
            final StringBuilder text = new StringBuilder("line ");
            text.append(lineNumber);
            text.append(": WARNING: ");
            text.append(message);
            text.append("\n    fields: ");
            for (int i=0; i<fields.size(); i++) {
                final String field = fields.get(i);
                if (field.indexOf('"') >= 0) {
                    text.append('"');
                    text.append(field.replace("\"", "\"\""));
                    text.append('"');
                } else {
                    text.append(field);
                }
                if (i != fields.size() - 1) {
                    text.append(',');
                }
            }
            text.append('\n');
            for (String extra: extras) {
                text.append("    extra: ");
                text.append(extra);
                text.append('\n');
            }
            System.err.print(text.toString());
        }
    }

    /**
     * Group records by class name.
     */
    private void indexRecords() {
        final HashMap<String,ArrayList<Record>> map = new HashMap<String,ArrayList<Record>>();

        // Iterate over all of the records
        for (Record record: mRecords) {
            final String className = record.getClass().getName();

            ArrayList<Record> list = map.get(className);
            if (list == null) {
                list = new ArrayList<Record>();
                map.put(className, list);
            }

            list.add(record);
        }

        // Make it immutable
        final HashMap<String,ImmutableList<Record>> result
                = new HashMap<String,ImmutableList<Record>>();
        for (HashMap.Entry<String,ArrayList<Record>> entry: map.entrySet()) {
            result.put(entry.getKey(), ImmutableList.copyOf(entry.getValue()));
        }

        // Initialize here so uninitialized access will result in NPE.
        mRecordsByType = ImmutableMap.copyOf(result);
    }

    /**
     * Collect the UIDs from the csv.
     *
     * They come from two places.
     * <ul>
     *   <li>The uid to package name map entries ({@link #Uid}) at the beginning.
     *   <li>The uid fields of the rest of the entries, some of which might not
     *       have package names associated with them.
     * </ul>
     *
     * TODO: Is this where we should also do the logic about the special UIDs?
     */
    private void indexApps() {
        final HashMap<Integer,HashSet<String>> uids = new HashMap<Integer,HashSet<String>>();

        // The Uid rows, from which we get package names
        for (Uid record: getMultiple(Uid.class)) {
            HashSet<String> list = uids.get(record.uidKey);
            if (list == null) {
                list = new HashSet<String>();
                uids.put(record.uidKey, list);
            }
            list.add(record.pkg);
        }

        // The uid fields of everything
        for (Record record: mRecords) {
            // The 0 in the INFO records isn't really root, it's just unfilled data.
            // The root uid (0) will show up practically in every record, but don't force it.
            if (record.category != Category.INFO) {
                if (uids.get(record.uid) == null) {
                    // There is no other data about this UID, but it does exist!
                    uids.put(record.uid, new HashSet<String>());
                }
            }
        }

        // Turn our temporary lists of package names into AttributionKeys.
        final HashSet<AttributionKey> result = new HashSet<AttributionKey>();
        for (HashMap.Entry<Integer,HashSet<String>> entry: uids.entrySet()) {
            result.add(new AttributionKey(entry.getKey(), entry.getValue()));
        }

        // Initialize here so uninitialized access will result in NPE.
        mApps = ImmutableSet.copyOf(result);
    }

    /**
     * Init the factory classes.
     */
    static {
        for (Class<?> cl: RawBatteryStats.class.getClasses()) {
            final Line lineAnnotation = cl.getAnnotation(Line.class);
            if (lineAnnotation != null && Record.class.isAssignableFrom(cl)) {
                final ArrayList<FieldSetter> fieldSetters = new ArrayList<FieldSetter>();

                for (java.lang.reflect.Field field: cl.getFields()) {
                    final Field fa = field.getAnnotation(Field.class);
                    if (fa != null) {
                        final Class<?> fieldType = field.getType();
                        final Class<?> innerType = fieldType.isArray()
                                ? fieldType.getComponentType()
                                : fieldType;
                        if (Integer.TYPE.equals(innerType)) {
                            fieldSetters.add(new IntFieldSetter(fa.index(), fa.added(), field));
                        } else if (Long.TYPE.equals(innerType)) {
                            fieldSetters.add(new LongFieldSetter(fa.index(), fa.added(), field));
                        } else if (String.class.equals(innerType)) {
                            fieldSetters.add(new StringFieldSetter(fa.index(), fa.added(), field));
                        } else if (innerType.isEnum()) {
                            fieldSetters.add(new EnumFieldSetter(fa.index(), fa.added(), field));
                        } else {
                            throw new RuntimeException("Unsupported field type '"
                                    + fieldType.getName() + "' on "
                                    + cl.getName() + "." + field.getName());
                        }
                    }
                }
                // Sort by index
                Collections.sort(fieldSetters, new Comparator<FieldSetter>() {
                            @Override
                            public int compare(FieldSetter a, FieldSetter b) {
                                return a.getIndex() - b.getIndex();
                            }
                        });
                // Only the last one can be an array
                for (int i=0; i<fieldSetters.size()-1; i++) {
                    if (fieldSetters.get(i).isArray()) {
                        throw new RuntimeException("Only the last (highest index) @Field"
                                + " in class " + cl.getName() + " can be an array: "
                                + fieldSetters.get(i).getName());
                    }
                }
                // Add to the map
                sFactories.put(lineAnnotation.tag(), new RecordFactory(lineAnnotation.tag(),
                            (Class<Record>)cl, fieldSetters));
            }
        }
    }
}