DiscoveryKeyUtils.java

Go to the documentation of this file.

/*
 * Autopsy
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * 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 org.sleuthkit.autopsy.discovery.search;

import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.centralrepository.datamodel.CentralRepository;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;

public class DiscoveryKeyUtils {

    private final static Logger logger = Logger.getLogger(DiscoveryKeyUtils.class.getName());

    static class SearchKey implements Comparable<SearchKey> {

        private final String keyString;
        private final Group.GroupSortingAlgorithm groupSortingType;
        private final DiscoveryAttributes.AttributeType groupAttributeType;
        private final ResultsSorter.SortingMethod sortingMethod;
        private final List<AbstractFilter> filters;
        private final SleuthkitCase sleuthkitCase;
        private final CentralRepository centralRepository;

        SearchKey(String userName, List<AbstractFilter> filters,
                DiscoveryAttributes.AttributeType groupAttributeType,
                Group.GroupSortingAlgorithm groupSortingType,
                ResultsSorter.SortingMethod sortingMethod,
                SleuthkitCase sleuthkitCase, CentralRepository centralRepository) {
            this.groupAttributeType = groupAttributeType;
            this.groupSortingType = groupSortingType;
            this.sortingMethod = sortingMethod;
            this.filters = filters;

            StringBuilder searchStringBuilder = new StringBuilder();
            searchStringBuilder.append(userName);
            for (AbstractFilter filter : filters) {
                searchStringBuilder.append(filter.toString());
            }
            searchStringBuilder.append(groupAttributeType).append(groupSortingType).append(sortingMethod);
            keyString = searchStringBuilder.toString();
            this.sleuthkitCase = sleuthkitCase;
            this.centralRepository = centralRepository;
        }

        SearchKey(String userName, List<AbstractFilter> filters,
                DiscoveryAttributes.AttributeType groupAttributeType,
                Group.GroupSortingAlgorithm groupSortingType,
                ResultsSorter.SortingMethod sortingMethod) {
            this(userName, filters, groupAttributeType, groupSortingType,
                    sortingMethod, null, null);
        }

        @Override
        public int compareTo(SearchKey otherSearchKey) {
            return getKeyString().compareTo(otherSearchKey.getKeyString());
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof SearchKey)) {
                return false;
            }

            SearchKey otherSearchKey = (SearchKey) otherKey;
            if (this.sleuthkitCase != otherSearchKey.getSleuthkitCase()
                    || this.centralRepository != otherSearchKey.getCentralRepository()) {
                return false;
            }

            return getKeyString().equals(otherSearchKey.getKeyString());
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 79 * hash + Objects.hashCode(getKeyString());
            return hash;
        }

        String getKeyString() {
            return keyString;
        }

        List<AbstractFilter> getFilters() {
            return Collections.unmodifiableList(this.filters);
        }

        Group.GroupSortingAlgorithm getGroupSortingType() {
            return groupSortingType;
        }

        DiscoveryAttributes.AttributeType getGroupAttributeType() {
            return groupAttributeType;
        }

        ResultsSorter.SortingMethod getFileSortingMethod() {
            return sortingMethod;
        }

        SleuthkitCase getSleuthkitCase() {
            return this.sleuthkitCase;
        }

        CentralRepository getCentralRepository() {
            return this.centralRepository;
        }
    }

    public abstract static class GroupKey implements Comparable<GroupKey> {

        abstract String getDisplayName();

        @Override
        abstract public boolean equals(Object otherKey);

        @Override
        abstract public int hashCode();

        int compareClassNames(GroupKey otherGroupKey) {
            return this.getClass().getName().compareTo(otherGroupKey.getClass().getName());
        }

        @Override
        public String toString() {
            return getDisplayName();
        }
    }

    static class FileSizeGroupKey extends GroupKey {

        private final SearchData.FileSize fileSize;

        FileSizeGroupKey(Result file) {
            ResultFile resultFile = (ResultFile) file;
            if (resultFile.getFileType() == SearchData.Type.VIDEO) {
                fileSize = SearchData.FileSize.fromVideoSize(resultFile.getFirstInstance().getSize());
            } else {
                fileSize = SearchData.FileSize.fromImageSize(resultFile.getFirstInstance().getSize());
            }
        }

        @Override
        String getDisplayName() {
            return getFileSize().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileSizeGroupKey) {
                FileSizeGroupKey otherFileSizeGroupKey = (FileSizeGroupKey) otherGroupKey;
                return Integer.compare(getFileSize().getRanking(), otherFileSizeGroupKey.getFileSize().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FileSizeGroupKey)) {
                return false;
            }

            FileSizeGroupKey otherFileSizeGroupKey = (FileSizeGroupKey) otherKey;
            return getFileSize().equals(otherFileSizeGroupKey.getFileSize());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFileSize().getRanking());
        }

        SearchData.FileSize getFileSize() {
            return fileSize;
        }
    }

    static class FileTypeGroupKey extends GroupKey {

        private final SearchData.Type fileType;

        FileTypeGroupKey(Result file) {
            fileType = ((ResultFile) file).getFileType();
        }

        @Override
        String getDisplayName() {
            return getFileType().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileTypeGroupKey) {
                FileTypeGroupKey otherFileTypeGroupKey = (FileTypeGroupKey) otherGroupKey;
                return Integer.compare(getFileType().getRanking(), otherFileTypeGroupKey.getFileType().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FileTypeGroupKey)) {
                return false;
            }

            FileTypeGroupKey otherFileTypeGroupKey = (FileTypeGroupKey) otherKey;
            return getFileType().equals(otherFileTypeGroupKey.getFileType());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFileType().getRanking());
        }

        SearchData.Type getFileType() {
            return fileType;
        }
    }

    static class KeywordListGroupKey extends GroupKey {

        private final List<String> keywordListNames;
        private final String keywordListNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.KeywordListGroupKey.noKeywords=None"})
        KeywordListGroupKey(ResultFile file) {
            keywordListNames = file.getKeywordListNames();
            if (keywordListNames.isEmpty()) {
                keywordListNamesString = Bundle.DiscoveryKeyUtils_KeywordListGroupKey_noKeywords();
            } else {
                keywordListNamesString = String.join(",", keywordListNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getKeywordListNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof KeywordListGroupKey) {
                KeywordListGroupKey otherKeywordListNamesGroupKey = (KeywordListGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getKeywordListNames().isEmpty()) {
                    if (otherKeywordListNamesGroupKey.getKeywordListNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherKeywordListNamesGroupKey.getKeywordListNames().isEmpty()) {
                    return -1;
                }

                return getKeywordListNamesString().compareTo(otherKeywordListNamesGroupKey.getKeywordListNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof KeywordListGroupKey)) {
                return false;
            }

            KeywordListGroupKey otherKeywordListGroupKey = (KeywordListGroupKey) otherKey;
            return getKeywordListNamesString().equals(otherKeywordListGroupKey.getKeywordListNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getKeywordListNamesString());
        }

        List<String> getKeywordListNames() {
            return Collections.unmodifiableList(keywordListNames);
        }

        String getKeywordListNamesString() {
            return keywordListNamesString;
        }
    }

    static class FileTagGroupKey extends GroupKey {

        private final List<String> tagNames;
        private final String tagNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.FileTagGroupKey.noSets=None"})
        FileTagGroupKey(ResultFile file) {
            tagNames = file.getTagNames();

            if (tagNames.isEmpty()) {
                tagNamesString = Bundle.DiscoveryKeyUtils_FileTagGroupKey_noSets();
            } else {
                tagNamesString = String.join(",", tagNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getTagNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FileTagGroupKey) {
                FileTagGroupKey otherFileTagGroupKey = (FileTagGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getTagNames().isEmpty()) {
                    if (otherFileTagGroupKey.getTagNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherFileTagGroupKey.getTagNames().isEmpty()) {
                    return -1;
                }

                return getTagNamesString().compareTo(otherFileTagGroupKey.getTagNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }
            if (!(otherKey instanceof FileTagGroupKey)) {
                return false;
            }
            FileTagGroupKey otherFileTagGroupKey = (FileTagGroupKey) otherKey;
            return getTagNamesString().equals(otherFileTagGroupKey.getTagNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getTagNamesString());
        }

        List<String> getTagNames() {
            return Collections.unmodifiableList(tagNames);
        }

        String getTagNamesString() {
            return tagNamesString;
        }
    }

    static class ParentPathGroupKey extends GroupKey {

        private String parentPath;
        private Long parentID;

        ParentPathGroupKey(ResultFile file) {
            Content parent;
            try {
                parent = file.getFirstInstance().getParent();
            } catch (TskCoreException ignored) {
                parent = null;
            }
            //Find the directory this file is in if it is an embedded file
            while (parent != null && parent instanceof AbstractFile && ((AbstractFile) parent).isFile()) {
                try {
                    parent = parent.getParent();
                } catch (TskCoreException ignored) {
                    parent = null;
                }
            }
            setParentPathAndID(parent, file);
        }

        private void setParentPathAndID(Content parent, ResultFile file) {
            if (parent != null) {
                try {
                    parentPath = parent.getUniquePath();
                    parentID = parent.getId();
                } catch (TskCoreException ignored) {
                    //catch block left blank purposefully next if statement will handle case when exception takes place as well as when parent is null
                }

            }
            if (parentPath == null) {
                if (file.getFirstInstance().getParentPath() != null) {
                    parentPath = file.getFirstInstance().getParentPath();
                } else {
                    parentPath = ""; // NON-NLS
                }
                parentID = -1L;
            }
        }

        @Override
        String getDisplayName() {
            return getParentPath();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof ParentPathGroupKey) {
                ParentPathGroupKey otherParentPathGroupKey = (ParentPathGroupKey) otherGroupKey;
                int comparisonResult = getParentPath().compareTo(otherParentPathGroupKey.getParentPath());
                if (comparisonResult == 0) {
                    comparisonResult = getParentID().compareTo(otherParentPathGroupKey.getParentID());
                }
                return comparisonResult;
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof ParentPathGroupKey)) {
                return false;
            }

            ParentPathGroupKey otherParentPathGroupKey = (ParentPathGroupKey) otherKey;
            return getParentPath().equals(otherParentPathGroupKey.getParentPath()) && getParentID().equals(otherParentPathGroupKey.getParentID());
        }

        @Override
        public int hashCode() {
            int hashCode = 11;
            hashCode = 61 * hashCode + Objects.hash(getParentPath());
            hashCode = 61 * hashCode + Objects.hash(getParentID());
            return hashCode;
        }

        String getParentPath() {
            return parentPath;
        }

        Long getParentID() {
            return parentID;
        }
    }

    static class DataSourceGroupKey extends GroupKey {

        private final long dataSourceID;
        private String displayName;

        @NbBundle.Messages({
            "# {0} - Data source name",
            "# {1} - Data source ID",
            "DiscoveryKeyUtils.DataSourceGroupKey.datasourceAndID={0}(ID: {1})",
            "# {0} - Data source ID",
            "DiscoveryKeyUtils.DataSourceGroupKey.idOnly=Data source (ID: {0})"})
        DataSourceGroupKey(Result result) {
            //get the id first so that it can be used when logging if necessary
            dataSourceID = result.getDataSourceObjectId();
            try {
                // The data source should be cached so this won't actually be a database query.
                Content ds = result.getDataSource();
                displayName = Bundle.DiscoveryKeyUtils_DataSourceGroupKey_datasourceAndID(ds.getName(), ds.getId());
            } catch (TskCoreException ex) {
                logger.log(Level.WARNING, "Error looking up data source with ID " + dataSourceID, ex); // NON-NLS
                displayName = Bundle.DiscoveryKeyUtils_DataSourceGroupKey_idOnly(dataSourceID);
            }
        }

        @Override
        String getDisplayName() {
            return displayName;
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof DataSourceGroupKey) {
                DataSourceGroupKey otherDataSourceGroupKey = (DataSourceGroupKey) otherGroupKey;
                return Long.compare(getDataSourceID(), otherDataSourceGroupKey.getDataSourceID());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof DataSourceGroupKey)) {
                return false;
            }

            DataSourceGroupKey otherDataSourceGroupKey = (DataSourceGroupKey) otherKey;
            return getDataSourceID() == otherDataSourceGroupKey.getDataSourceID();
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDataSourceID());
        }

        long getDataSourceID() {
            return dataSourceID;
        }
    }

    static class NoGroupingGroupKey extends GroupKey {

        NoGroupingGroupKey() {
            // Nothing to save - all files will get the same GroupKey
        }

        @NbBundle.Messages({
            "DiscoveryKeyUtils.NoGroupingGroupKey.allFiles=All Files"})
        @Override
        String getDisplayName() {
            return Bundle.DiscoveryKeyUtils_NoGroupingGroupKey_allFiles();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            // As long as the other key is the same type, they are equal
            if (otherGroupKey instanceof NoGroupingGroupKey) {
                return 0;
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }
            // As long as the other key is the same type, they are equal
            return otherKey instanceof NoGroupingGroupKey;
        }

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

    static class FrequencyGroupKey extends GroupKey {

        private final SearchData.Frequency frequency;

        FrequencyGroupKey(Result result) {
            frequency = result.getFrequency();
        }

        @Override
        String getDisplayName() {
            return getFrequency().toString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FrequencyGroupKey) {
                FrequencyGroupKey otherFrequencyGroupKey = (FrequencyGroupKey) otherGroupKey;
                return Integer.compare(getFrequency().getRanking(), otherFrequencyGroupKey.getFrequency().getRanking());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FrequencyGroupKey)) {
                return false;
            }

            FrequencyGroupKey otherFrequencyGroupKey = (FrequencyGroupKey) otherKey;
            return getFrequency().equals(otherFrequencyGroupKey.getFrequency());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getFrequency().getRanking());
        }

        SearchData.Frequency getFrequency() {
            return frequency;
        }
    }

    static class HashHitsGroupKey extends GroupKey {

        private final List<String> hashSetNames;
        private final String hashSetNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.HashHitsGroupKey.noHashHits=None"})
        HashHitsGroupKey(ResultFile file) {
            hashSetNames = file.getHashSetNames();

            if (hashSetNames.isEmpty()) {
                hashSetNamesString = Bundle.DiscoveryKeyUtils_HashHitsGroupKey_noHashHits();
            } else {
                hashSetNamesString = String.join(",", hashSetNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getHashSetNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof HashHitsGroupKey) {
                HashHitsGroupKey otherHashHitsGroupKey = (HashHitsGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (getHashSetNames().isEmpty()) {
                    if (otherHashHitsGroupKey.getHashSetNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherHashHitsGroupKey.getHashSetNames().isEmpty()) {
                    return -1;
                }

                return getHashSetNamesString().compareTo(otherHashHitsGroupKey.getHashSetNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof HashHitsGroupKey)) {
                return false;
            }

            HashHitsGroupKey otherHashHitsGroupKey = (HashHitsGroupKey) otherKey;
            return getHashSetNamesString().equals(otherHashHitsGroupKey.getHashSetNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getHashSetNamesString());
        }

        List<String> getHashSetNames() {
            return Collections.unmodifiableList(hashSetNames);
        }

        String getHashSetNamesString() {
            return hashSetNamesString;
        }
    }

    static class InterestingItemGroupKey extends GroupKey {

        private final List<String> interestingItemSetNames;
        private final String interestingItemSetNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.InterestingItemGroupKey.noSets=None"})
        InterestingItemGroupKey(ResultFile file) {
            interestingItemSetNames = file.getInterestingSetNames();

            if (interestingItemSetNames.isEmpty()) {
                interestingItemSetNamesString = Bundle.DiscoveryKeyUtils_InterestingItemGroupKey_noSets();
            } else {
                interestingItemSetNamesString = String.join(",", interestingItemSetNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getInterestingItemSetNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof InterestingItemGroupKey) {
                InterestingItemGroupKey otherInterestingItemGroupKey = (InterestingItemGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getInterestingItemSetNames().isEmpty()) {
                    if (otherInterestingItemGroupKey.getInterestingItemSetNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherInterestingItemGroupKey.getInterestingItemSetNames().isEmpty()) {
                    return -1;
                }

                return getInterestingItemSetNamesString().compareTo(otherInterestingItemGroupKey.getInterestingItemSetNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof InterestingItemGroupKey)) {
                return false;
            }

            InterestingItemGroupKey otherInterestingItemGroupKey = (InterestingItemGroupKey) otherKey;
            return getInterestingItemSetNamesString().equals(otherInterestingItemGroupKey.getInterestingItemSetNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getInterestingItemSetNamesString());
        }

        List<String> getInterestingItemSetNames() {
            return Collections.unmodifiableList(interestingItemSetNames);
        }

        String getInterestingItemSetNamesString() {
            return interestingItemSetNamesString;
        }
    }

    static class MostRecentActivityDateGroupKey extends GroupKey {

        private final Long epochDate;
        private final String dateNameString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.MostRecentActivityDateGroupKey.noDate=No Date Available"})
        MostRecentActivityDateGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                epochDate = ((ResultDomain) result).getActivityEnd();
                dateNameString = new SimpleDateFormat("yyyy/MM/dd", Locale.getDefault()).format(new Date(TimeUnit.SECONDS.toMillis(epochDate)));
            } else {
                epochDate = Long.MAX_VALUE;
                dateNameString = Bundle.DiscoveryKeyUtils_MostRecentActivityDateGroupKey_noDate();
            }
        }

        @Override
        String getDisplayName() {
            return getDateNameString();
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof MostRecentActivityDateGroupKey)) {
                return false;
            }

            MostRecentActivityDateGroupKey dateGroupKey = (MostRecentActivityDateGroupKey) otherKey;
            return getDateNameString().equals(dateGroupKey.getDateNameString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDateNameString());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof MostRecentActivityDateGroupKey) {
                MostRecentActivityDateGroupKey otherDateGroupKey = (MostRecentActivityDateGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getEpochDate().equals(Long.MAX_VALUE)) {
                    if (otherDateGroupKey.getEpochDate().equals(Long.MAX_VALUE)) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherDateGroupKey.getEpochDate().equals(Long.MAX_VALUE)) {
                    return -1;
                }

                return getDateNameString().compareTo(otherDateGroupKey.getDateNameString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        Long getEpochDate() {
            return epochDate;
        }

        String getDateNameString() {
            return dateNameString;
        }
    }

    static class FirstActivityDateGroupKey extends GroupKey {

        private final Long epochDate;
        private final String dateNameString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.FirstActivityDateGroupKey.noDate=No Date Available"})
        FirstActivityDateGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                epochDate = ((ResultDomain) result).getActivityStart();
                dateNameString = new SimpleDateFormat("yyyy/MM/dd", Locale.getDefault()).format(new Date(TimeUnit.SECONDS.toMillis(epochDate)));
            } else {
                epochDate = Long.MAX_VALUE;
                dateNameString = Bundle.DiscoveryKeyUtils_FirstActivityDateGroupKey_noDate();
            }
        }

        @Override
        String getDisplayName() {
            return getDateNameString();
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof FirstActivityDateGroupKey)) {
                return false;
            }

            FirstActivityDateGroupKey dateGroupKey = (FirstActivityDateGroupKey) otherKey;
            return getDateNameString().equals(dateGroupKey.getDateNameString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getDateNameString());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof FirstActivityDateGroupKey) {
                FirstActivityDateGroupKey otherDateGroupKey = (FirstActivityDateGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getEpochDate().equals(Long.MAX_VALUE)) {
                    if (otherDateGroupKey.getEpochDate().equals(Long.MAX_VALUE)) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherDateGroupKey.getEpochDate().equals(Long.MAX_VALUE)) {
                    return -1;
                }

                return getDateNameString().compareTo(otherDateGroupKey.getDateNameString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        Long getEpochDate() {
            return epochDate;
        }

        String getDateNameString() {
            return dateNameString;
        }
    }

    static class NumberOfVisitsGroupKey extends GroupKey {

        private final String displayName;
        private final Long visits;

        @NbBundle.Messages({
            "# {0} - totalVisits",
            "DiscoveryKeyUtils.NumberOfVisitsGroupKey.displayName={0} visits",
            "DiscoveryKeyUtils.NumberOfVisitsGroupKey.noVisits=No visits"})
        NumberOfVisitsGroupKey(Result result) {
            if (result instanceof ResultDomain) {
                Long totalVisits = ((ResultDomain) result).getTotalVisits();
                if (totalVisits == null) {
                    totalVisits = 0L;
                }
                visits = totalVisits;
                displayName = Bundle.DiscoveryKeyUtils_NumberOfVisitsGroupKey_displayName(Long.toString(visits));
            } else {
                displayName = Bundle.DiscoveryKeyUtils_NumberOfVisitsGroupKey_noVisits();
                visits = -1L;
            }
        }

        @Override
        String getDisplayName() {
            return displayName;
        }

        @Override
        public int hashCode() {
            return Objects.hash(displayName);
        }

        Long getVisits() {
            return visits;
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof NumberOfVisitsGroupKey)) {
                return false;
            }

            NumberOfVisitsGroupKey visitsKey = (NumberOfVisitsGroupKey) otherKey;
            return visits.equals(visitsKey.getVisits());
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof NumberOfVisitsGroupKey) {
                NumberOfVisitsGroupKey visitsKey = (NumberOfVisitsGroupKey) otherGroupKey;
                return Long.compare(getVisits(), visitsKey.getVisits());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }
    }

    static class ObjectDetectedGroupKey extends GroupKey {

        private final List<String> objectDetectedNames;
        private final String objectDetectedNamesString;

        @NbBundle.Messages({
            "DiscoveryKeyUtils.ObjectDetectedGroupKey.noSets=None"})
        ObjectDetectedGroupKey(ResultFile file) {
            objectDetectedNames = file.getObjectDetectedNames();
            if (objectDetectedNames.isEmpty()) {
                objectDetectedNamesString = Bundle.DiscoveryKeyUtils_ObjectDetectedGroupKey_noSets();
            } else {
                objectDetectedNamesString = String.join(",", objectDetectedNames); // NON-NLS
            }
        }

        @Override
        String getDisplayName() {
            return getObjectDetectedNamesString();
        }

        @Override
        public int compareTo(GroupKey otherGroupKey) {
            if (otherGroupKey instanceof ObjectDetectedGroupKey) {
                ObjectDetectedGroupKey otherObjectDetectedGroupKey = (ObjectDetectedGroupKey) otherGroupKey;

                // Put the empty list at the end
                if (this.getObjectDetectedNames().isEmpty()) {
                    if (otherObjectDetectedGroupKey.getObjectDetectedNames().isEmpty()) {
                        return 0;
                    } else {
                        return 1;
                    }
                } else if (otherObjectDetectedGroupKey.getObjectDetectedNames().isEmpty()) {
                    return -1;
                }

                return getObjectDetectedNamesString().compareTo(otherObjectDetectedGroupKey.getObjectDetectedNamesString());
            } else {
                return compareClassNames(otherGroupKey);
            }
        }

        @Override
        public boolean equals(Object otherKey) {
            if (otherKey == this) {
                return true;
            }

            if (!(otherKey instanceof ObjectDetectedGroupKey)) {
                return false;
            }

            ObjectDetectedGroupKey otherObjectDetectedGroupKey = (ObjectDetectedGroupKey) otherKey;
            return getObjectDetectedNamesString().equals(otherObjectDetectedGroupKey.getObjectDetectedNamesString());
        }

        @Override
        public int hashCode() {
            return Objects.hash(getObjectDetectedNamesString());
        }

        List<String> getObjectDetectedNames() {
            return Collections.unmodifiableList(objectDetectedNames);
        }

        String getObjectDetectedNamesString() {
            return objectDetectedNamesString;
        }
    }

    private DiscoveryKeyUtils() {
        //private constructor in a utility class intentionally left blank
    }
}