KMLReport.java

Go to the documentation of this file.

/*
 *
 * Autopsy Forensic Browser
 *
 * Copyright 2014-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.report.modules.kml;

import org.sleuthkit.autopsy.report.GeneralReportModule;
import javax.swing.JPanel;
import org.openide.util.NbBundle;
import org.sleuthkit.autopsy.casemodule.Case;
import org.sleuthkit.autopsy.coreutils.Logger;
import org.sleuthkit.autopsy.ingest.IngestManager;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.logging.Level;
import java.util.stream.Collectors;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.Namespace;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.jdom2.CDATA;
import org.openide.filesystems.FileUtil;
import org.openide.util.NbBundle.Messages;
import org.sleuthkit.autopsy.casemodule.NoCurrentCaseException;
import org.sleuthkit.autopsy.geolocation.datamodel.GeoLocationDataException;
import org.sleuthkit.autopsy.geolocation.datamodel.GeoLocationParseResult;
import org.sleuthkit.autopsy.geolocation.datamodel.Waypoint;
import org.sleuthkit.autopsy.geolocation.datamodel.Route;
import org.sleuthkit.autopsy.geolocation.datamodel.Track;
import org.sleuthkit.autopsy.geolocation.datamodel.WaypointBuilder;
import org.sleuthkit.autopsy.report.GeneralReportSettings;
import org.sleuthkit.autopsy.report.ReportBranding;
import org.sleuthkit.autopsy.report.ReportProgressPanel;
import org.sleuthkit.datamodel.AbstractFile;
import org.sleuthkit.datamodel.Content;
import org.sleuthkit.datamodel.ReadContentInputStream;
import org.sleuthkit.datamodel.ReadContentInputStream.ReadContentInputStreamException;
import org.sleuthkit.datamodel.SleuthkitCase;
import org.sleuthkit.datamodel.TskCoreException;

public final class KMLReport implements GeneralReportModule {

    private static final Logger logger = Logger.getLogger(KMLReport.class.getName());
    private static final String KML_STYLE_FILE = "style.kml";
    private static final String REPORT_KML = "ReportKML.kml";
    private static final String STYLESHEETS_PATH = "/org/sleuthkit/autopsy/report/stylesheets/";
    private static KMLReport instance = null;
    private Case currentCase;
    private SleuthkitCase skCase;
    private final SimpleDateFormat kmlDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX");
    private Namespace ns;
    private final static String HTML_PROP_FORMAT = "<b>%s: </b>%s<br>";

    private Element gpsExifMetadataFolder;
    private Element gpsBookmarksFolder;
    private Element gpsLastKnownLocationFolder;
    private Element gpsRouteFolder;
    private Element gpsSearchesFolder;
    private Element gpsTrackpointsFolder;
    private Element gpsTracksFolder;
    
    private GeneralReportSettings settings;

    private List<Waypoint> waypointList = null;

    private enum FeatureColor {
        RED("style.kml#redFeature"),
        GREEN("style.kml#greenFeature"),
        BLUE("style.kml#blueFeature"),
        PURPLE("style.kml#purpleFeature"),
        WHITE("style.kml#whiteFeature"),
        YELLOW("style.kml#yellowFeature");
        private final String color;

        FeatureColor(String color) {
            this.color = color;
        }

        String getColor() {
            return this.color;
        }
    }

    // Hidden constructor for the report
    private KMLReport() {
    }

    // Get the default implementation of this report
    public static synchronized KMLReport getDefault() {
        if (instance == null) {
            instance = new KMLReport();
        }
        return instance;
    }

    @Messages({
        "KMLReport.failedToCompleteReport=Failed to complete report.",
        "KMLReport.partialFailure=There was an error creating the report.  Some items were not exported.",
        "KMLReport.unableToExtractPhotos=Could not extract photo information.",
        "KMLReport.exifPhotoError=Could not extract photos with EXIF metadata.",
        "KMLReport.bookmarkError=Could not extract Bookmark information.",
        "KMLReport.gpsBookmarkError=Could not get GPS Bookmarks from database.",
        "KMLReport.locationError=Could not extract Last Known Location information.",
        "KMLReport.locationDatabaseError=Could not get GPS Last Known Location from database.",
        "KMLReport.gpsRouteError=Could not extract GPS Route information.",
        "KMLReport.gpsRouteDatabaseError=Could not get GPS Routes from database.",
        "KMLReport.gpsSearchDatabaseError=Could not get GPS Searches from database.",
        "KMLReport.trackpointError=Could not extract Trackpoint information.",
        "KMLReport.trackpointDatabaseError=Could not get GPS Trackpoints from database.",
        "KMLReport.stylesheetError=Error placing KML stylesheet. The .KML file will not function properly.",
        "KMLReport.kmlFileWriteError=Could not write the KML file.",
        "# {0} - filePath",
        "KMLReport.errorGeneratingReport=Error adding {0} to case as a report.",
        "KMLReport.unableToOpenCase=Exception while getting open case.",
        "Waypoint_Bookmark_Display_String=GPS Bookmark",
        "Waypoint_Last_Known_Display_String=GPS Last Known Location",
        "Waypoint_EXIF_Display_String=EXIF Metadata With Location",
        "Waypoint_Route_Point_Display_String=GPS Individual Route Point",
        "Waypoint_Search_Display_String=GPS Search",
        "Waypoint_Trackpoint_Display_String=GPS Trackpoint",
        "Waypoint_Track_Display_String=GPS Track",
        "Route_Details_Header=GPS Route",
        "ReportBodyFile.ingestWarning.text=Ingest Warning message",
        "Waypoint_Track_Point_Display_String=GPS Individual Track Point"
    })

    public void generateReport(String baseReportDir, ReportProgressPanel progressPanel, List<Waypoint> waypointList) {
        this.waypointList = waypointList;
        GeneralReportSettings reportSettings = new GeneralReportSettings();
        reportSettings.setReportDirectoryPath(baseReportDir);
        generateReport(reportSettings, progressPanel);
    }
    
    @Override
    public boolean supportsDataSourceSelection() {
        return true;
    }
    
    @Override
    public void generateReport(GeneralReportSettings settings, ReportProgressPanel progressPanel) {
        try {
            currentCase = Case.getCurrentCaseThrows();
        } catch (NoCurrentCaseException ex) {
            logger.log(Level.SEVERE, "Exception while getting open case.", ex); //NON-NLS
            return;
        }
        
        if(settings.getSelectedDataSources() == null) {
            // Process all data sources if the list is null.
            try {
                List<Long> selectedDataSources = currentCase.getDataSources()
                        .stream()
                        .map(Content::getId)
                        .collect(Collectors.toList());
                settings.setSelectedDataSources(selectedDataSources);
            } catch (TskCoreException ex) {
                logger.log(Level.SEVERE, "Could not get the datasources from the case", ex);
                return;
            }
        }
        
        String baseReportDir = settings.getReportDirectoryPath();
        this.settings = settings;
        // Start the progress bar and setup the report
        progressPanel.setIndeterminate(true);
        progressPanel.start();
        progressPanel.updateStatusLabel(NbBundle.getMessage(this.getClass(), "ReportKML.progress.querying"));
        String kmlFileFullPath = baseReportDir + REPORT_KML; //NON-NLS
        String errorMessage = "";

        skCase = currentCase.getSleuthkitCase();

        progressPanel.updateStatusLabel(NbBundle.getMessage(this.getClass(), "ReportKML.progress.loading"));

        Document kmlDocument = setupReportDocument();

        ReportProgressPanel.ReportStatus result = ReportProgressPanel.ReportStatus.COMPLETE;

        try {
            makeRoutes(skCase);
            boolean entirelySuccessful = makeTracks(skCase);
            if (!entirelySuccessful) {
                result = ReportProgressPanel.ReportStatus.ERROR;
                errorMessage = Bundle.KMLReport_partialFailure();
            }
            
            addLocationsToReport(skCase, baseReportDir);
        } catch (GeoLocationDataException | IOException | TskCoreException ex) {
            errorMessage = Bundle.KMLReport_failedToCompleteReport();
            logger.log(Level.SEVERE, errorMessage, ex); //NON-NLS
            result = ReportProgressPanel.ReportStatus.ERROR;
        }

        // Copy the style sheet
        try {
            InputStream input = getClass().getResourceAsStream(STYLESHEETS_PATH + KML_STYLE_FILE); // Preserve slash direction
            OutputStream output = new FileOutputStream(baseReportDir + KML_STYLE_FILE); // Preserve slash direction
            FileUtil.copy(input, output);
        } catch (IOException ex) {
            errorMessage = Bundle.KMLReport_stylesheetError();
            logger.log(Level.SEVERE, errorMessage, ex); //NON-NLS
            result = ReportProgressPanel.ReportStatus.ERROR;
        }

        try (FileOutputStream writer = new FileOutputStream(kmlFileFullPath)) {
            XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
            outputter.output(kmlDocument, writer);
            String prependedStatus = "";
            if (result == ReportProgressPanel.ReportStatus.ERROR) {
                prependedStatus = "Incomplete ";
            }
            Case.getCurrentCaseThrows().addReport(kmlFileFullPath,
                    NbBundle.getMessage(this.getClass(), "ReportKML.genReport.srcModuleName.text"),
                    prependedStatus + NbBundle.getMessage(this.getClass(), "ReportKML.genReport.reportName"));
        } catch (IOException ex) {
            errorMessage = Bundle.KMLReport_kmlFileWriteError();
            logger.log(Level.SEVERE, errorMessage, ex); //NON-NLS
            progressPanel.complete(ReportProgressPanel.ReportStatus.ERROR, errorMessage);
        } catch (TskCoreException ex) {
            errorMessage = Bundle.KMLReport_errorGeneratingReport(kmlFileFullPath);
            logger.log(Level.SEVERE, errorMessage, ex);
            result = ReportProgressPanel.ReportStatus.ERROR;
        } catch (NoCurrentCaseException ex) {
            errorMessage = Bundle.KMLReport_unableToOpenCase();
            logger.log(Level.SEVERE, errorMessage, ex);
            result = ReportProgressPanel.ReportStatus.ERROR;
        }

        progressPanel.complete(result, errorMessage);
    }

    private Document setupReportDocument() {
        ns = Namespace.getNamespace("", "http://www.opengis.net/kml/2.2"); //NON-NLS

        Element kml = new Element("kml", ns); //NON-NLS
        kml.addNamespaceDeclaration(Namespace.getNamespace("gx", "http://www.google.com/kml/ext/2.2")); //NON-NLS
        kml.addNamespaceDeclaration(Namespace.getNamespace("kml", "http://www.opengis.net/kml/2.2")); //NON-NLS
        kml.addNamespaceDeclaration(Namespace.getNamespace("atom", "http://www.w3.org/2005/Atom")); //NON-NLS
        Document kmlDocument = new Document(kml);

        Element document = new Element("Document", ns); //NON-NLS
        kml.addContent(document);

        Element name = new Element("name", ns); //NON-NLS
        ReportBranding rb = new ReportBranding();
        name.setText(rb.getReportTitle() + " KML"); //NON-NLS
        document.addContent(name);

        // Check if ingest has finished
        if (IngestManager.getInstance().isIngestRunning()) {
            Element ingestwarning = new Element("snippet", ns); //NON-NLS
            ingestwarning.addContent(NbBundle.getMessage(this.getClass(), "ReportBodyFile.ingestWarning.text")); //NON-NLS
            document.addContent(ingestwarning);
        }

        // Create folder structure
        gpsExifMetadataFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataExifMetadataFolder = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/camera-icon-16.png"); //NON-NLS
        Element hrefExifMetadata = new Element("href", ns).addContent(cdataExifMetadataFolder); //NON-NLS
        gpsExifMetadataFolder.addContent(new Element("Icon", ns).addContent(hrefExifMetadata)); //NON-NLS

        gpsBookmarksFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataBookmarks = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gpsfav.png"); //NON-NLS
        Element hrefBookmarks = new Element("href", ns).addContent(cdataBookmarks); //NON-NLS
        gpsBookmarksFolder.addContent(new Element("Icon", ns).addContent(hrefBookmarks)); //NON-NLS

        gpsLastKnownLocationFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataLastKnownLocation = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gps-lastlocation.png"); //NON-NLS
        Element hrefLastKnownLocation = new Element("href", ns).addContent(cdataLastKnownLocation); //NON-NLS
        gpsLastKnownLocationFolder.addContent(new Element("Icon", ns).addContent(hrefLastKnownLocation)); //NON-NLS

        gpsRouteFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataRoute = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gps-trackpoint.png"); //NON-NLS
        Element hrefRoute = new Element("href", ns).addContent(cdataRoute); //NON-NLS
        gpsRouteFolder.addContent(new Element("Icon", ns).addContent(hrefRoute)); //NON-NLS

        gpsSearchesFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataSearches = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gps-search.png"); //NON-NLS
        Element hrefSearches = new Element("href", ns).addContent(cdataSearches); //NON-NLS
        gpsSearchesFolder.addContent(new Element("Icon", ns).addContent(hrefSearches)); //NON-NLS

        gpsTrackpointsFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataTrackpoints = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gps-trackpoint.png"); //NON-NLS
        Element hrefTrackpoints = new Element("href", ns).addContent(cdataTrackpoints); //NON-NLS
        gpsTrackpointsFolder.addContent(new Element("Icon", ns).addContent(hrefTrackpoints)); //NON-NLS

        gpsTracksFolder = new Element("Folder", ns); //NON-NLS
        CDATA cdataTrack = new CDATA("https://raw.githubusercontent.com/sleuthkit/autopsy/develop/Core/src/org/sleuthkit/autopsy/images/gps-trackpoint.png"); //NON-NLS
        Element hrefTrack = new Element("href", ns).addContent(cdataTrack); //NON-NLS
        gpsTracksFolder.addContent(new Element("Icon", ns).addContent(hrefTrack)); //NON-NLS

        gpsExifMetadataFolder.addContent(new Element("name", ns).addContent("EXIF Metadata")); //NON-NLS
        gpsBookmarksFolder.addContent(new Element("name", ns).addContent("GPS Bookmarks")); //NON-NLS
        gpsLastKnownLocationFolder.addContent(new Element("name", ns).addContent("GPS Last Known Location")); //NON-NLS
        gpsRouteFolder.addContent(new Element("name", ns).addContent("GPS Routes")); //NON-NLS
        gpsSearchesFolder.addContent(new Element("name", ns).addContent("GPS Searches")); //NON-NLS
        gpsTrackpointsFolder.addContent(new Element("name", ns).addContent("GPS Trackpoints")); //NON-NLS
        gpsTracksFolder.addContent(new Element("name", ns).addContent("GPS Tracks")); //NON-NLS

        document.addContent(gpsExifMetadataFolder);
        document.addContent(gpsBookmarksFolder);
        document.addContent(gpsLastKnownLocationFolder);
        document.addContent(gpsRouteFolder);
        document.addContent(gpsSearchesFolder);
        document.addContent(gpsTrackpointsFolder);
        document.addContent(gpsTracksFolder);

        return kmlDocument;
    }

    void addExifMetadataContent(List<Waypoint> points, String baseReportDirectory) throws IOException, TskCoreException {
        for (Waypoint point : points) {
            if(shouldFilterFromReport(point.getArtifact())) {
                continue;
            }
            
            Element mapPoint = makePoint(point);
            if (mapPoint == null) {
                return;
            }

            AbstractFile abstractFile = point.getImage();
            String details = getFormattedDetails(point, Bundle.Waypoint_EXIF_Display_String());

            Path path;
            copyFileUsingStream(abstractFile, Paths.get(baseReportDirectory, abstractFile.getName()).toFile());
            try {
                path = Paths.get(removeLeadingImgAndVol(abstractFile.getUniquePath()));
            } catch (TskCoreException ex) {
                path = Paths.get(abstractFile.getParentPath(), abstractFile.getName());
            }
            if (path == null) {
                path = Paths.get(abstractFile.getName());
            }

            gpsExifMetadataFolder.addContent(makePlacemarkWithPicture(abstractFile.getName(), FeatureColor.RED, details, point.getTimestamp(), mapPoint, path, formattedCoordinates(point.getLatitude(), point.getLongitude())));
        }
    }

    void addLocationsToReport(SleuthkitCase skCase, String baseReportDir) throws GeoLocationDataException, IOException, TskCoreException {
        if (waypointList == null) {
            addExifMetadataContent(WaypointBuilder.getEXIFWaypoints(skCase), baseReportDir);
            addWaypoints(WaypointBuilder.getBookmarkWaypoints(skCase), gpsBookmarksFolder, FeatureColor.BLUE, Bundle.Waypoint_Bookmark_Display_String());
            addWaypoints(WaypointBuilder.getLastKnownWaypoints(skCase), gpsLastKnownLocationFolder, FeatureColor.PURPLE, Bundle.Waypoint_Last_Known_Display_String());
            addWaypoints(WaypointBuilder.getSearchWaypoints(skCase), gpsSearchesFolder, FeatureColor.WHITE, Bundle.Waypoint_Search_Display_String());
            addWaypoints(WaypointBuilder.getTrackpointWaypoints(skCase), gpsTrackpointsFolder, FeatureColor.WHITE, Bundle.Waypoint_Trackpoint_Display_String());
        } else {
            addExifMetadataContent(WaypointBuilder.getEXIFWaypoints(waypointList), baseReportDir);
            addWaypoints(WaypointBuilder.getBookmarkWaypoints(waypointList), gpsBookmarksFolder, FeatureColor.BLUE, Bundle.Waypoint_Bookmark_Display_String());
            addWaypoints(WaypointBuilder.getLastKnownWaypoints(waypointList), gpsLastKnownLocationFolder, FeatureColor.PURPLE, Bundle.Waypoint_Last_Known_Display_String());
            addWaypoints(WaypointBuilder.getSearchWaypoints(waypointList), gpsSearchesFolder, FeatureColor.WHITE, Bundle.Waypoint_Search_Display_String());
            addWaypoints(WaypointBuilder.getTrackpointWaypoints(waypointList), gpsTrackpointsFolder, FeatureColor.WHITE, Bundle.Waypoint_Trackpoint_Display_String());
        }
    }

    void addWaypoints(List<Waypoint> points, Element folder, FeatureColor waypointColor, String headerLabel) throws TskCoreException {
        for (Waypoint point : points) {
            if(shouldFilterFromReport(point.getArtifact())) {
                continue;
            }
            addContent(folder, point.getLabel(), waypointColor, getFormattedDetails(point, headerLabel), point.getTimestamp(), makePoint(point), point.getLatitude(), point.getLongitude());
        }
    }

    void addContent(Element folder, String waypointLabel, FeatureColor waypointColor, String formattedDetails, Long timestamp, Element point, Double latitude, Double longitude) {
        if (folder != null && point != null) {
            String formattedCords = formattedCoordinates(latitude, longitude);
            folder.addContent(makePlacemark(waypointLabel, waypointColor, formattedDetails, timestamp, point, formattedCords));
        }
    }

    void makeRoutes(SleuthkitCase skCase) throws GeoLocationDataException, TskCoreException {
        List<Route> routes = null;

        if (waypointList == null) {
            routes = Route.getRoutes(skCase);
        } else {
            routes = WaypointBuilder.getRoutes(waypointList);
        }

        for (Route route : routes) {
            if(shouldFilterFromReport(route.getArtifact())) {
                continue;
            }
            addRouteToReport(route);   
        }
    }

    private void addRouteToReport(Route route) {
        List<Waypoint> routePoints = route.getRoute();
        Waypoint start = null;
        Waypoint end = null;
        // This is hardcoded knowledge that there is only two points
        // a start and end.  In the long run it would be nice to 
        // support the idea of a route with multiple points.  The Route
        // class supports that idea.  Would be nice to figure out how to support
        // for report.
        if (routePoints != null && routePoints.size() > 1) {
            start = routePoints.get(0);
            end = routePoints.get(1);
        }

        if (start == null || end == null) {
            return;
        }

        Element reportRoute = makeLineString(start.getLatitude(), start.getLongitude(), end.getLatitude(), end.getLongitude());
        Element startingPoint = makePoint(start.getLatitude(), start.getLongitude(), start.getAltitude());
        Element endingPoint = makePoint(end.getLatitude(), end.getLongitude(), end.getAltitude());

        String formattedEnd = formattedCoordinates(end.getLatitude(), end.getLongitude());
        String formattedStart = formattedCoordinates(start.getLatitude(), start.getLongitude());

        String formattedCoordinates = String.format("%s to %s", formattedStart, formattedEnd);

        if (reportRoute != null) {
            gpsRouteFolder.addContent(makePlacemark(route.getLabel(), FeatureColor.GREEN, getFormattedDetails(route), route.getTimestamp(), reportRoute, formattedCoordinates)); //NON-NLS
        }

        if (startingPoint != null) {
            gpsRouteFolder.addContent(makePlacemark(start.getLabel(),
                    FeatureColor.GREEN, getFormattedDetails(start, Bundle.Waypoint_Route_Point_Display_String()),
                    start.getTimestamp(), startingPoint, formattedStart)); //NON-NLS
        }

        if (endingPoint != null) {
            gpsRouteFolder.addContent(makePlacemark(end.getLabel(),
                    FeatureColor.GREEN,
                    getFormattedDetails(end, Bundle.Waypoint_Route_Point_Display_String()),
                    end.getTimestamp(), endingPoint, formattedEnd)); //NON-NLS
        }
    }

    boolean makeTracks(SleuthkitCase skCase) throws GeoLocationDataException, TskCoreException {
        List<Track> tracks = null;
        boolean successful = true;
        
        if (waypointList == null) {
            GeoLocationParseResult<Track> result = Track.getTracks(skCase, null);
            tracks = result.getItems();
            successful = result.isSuccessfullyParsed();
        } else {
            tracks = WaypointBuilder.getTracks(waypointList);
        }

        for (Track track : tracks) {
            if(shouldFilterFromReport(track.getArtifact())) {
                continue;
            }
            addTrackToReport(track);
        }
        
        return successful;
    }

    private void addTrackToReport(Track track) {
        List<Waypoint> trackPoints = track.getPath();

        // Adding a folder with the track name so that all of the 
        // tracks waypoints with be grouped together.
        Element trackFolder = new Element("Folder", ns); //NON-NLS
        trackFolder.addContent(new Element("name", ns).addContent(track.getLabel())); //NON-NLS
        gpsTracksFolder.addContent(trackFolder);

        for (Waypoint point : trackPoints) {
            Element element = makePoint(point.getLatitude(), point.getLongitude(), point.getAltitude());
            trackFolder.addContent(makePlacemark("",
                    FeatureColor.GREEN, getFormattedDetails(point, Bundle.Waypoint_Track_Point_Display_String()),
                    point.getTimestamp(), element, formattedCoordinates(point.getLatitude(), point.getLongitude()))); //NON-NLS
        }
    }

    private String getTimeStamp(long timeStamp) {
        return kmlDateFormat.format(new java.util.Date(timeStamp * 1000));
    }

    private Element makePoint(Waypoint point) {
        return makePoint(point.getLatitude(), point.getLongitude(), point.getAltitude());
    }

    private Element makePoint(Double latitude, Double longitude, Double altitude) {
        if (latitude == null || longitude == null) {
            return null;
        }

        Element point = new Element("Point", ns); //NON-NLS

        // KML uses lon, lat. Deliberately reversed.1
        Element coordinates = new Element("coordinates", ns).addContent(longitude + "," + latitude + "," + (altitude != null ? altitude : 0.0)); //NON-NLS

        if (altitude != null && altitude != 0) {
            /*
             * Though we are including a non-zero altitude, clamp it to the
             * ground because inaccuracies from the GPS data can cause the
             * terrain to occlude points when zoomed in otherwise. Show the
             * altitude, but keep the point clamped to the ground. We may change
             * this later for flying GPS sensors.
             */
            Element altitudeMode = new Element("altitudeMode", ns).addContent("clampToGround"); //NON-NLS
            point.addContent(altitudeMode);
        }
        point.addContent(coordinates);

        return point;
    }

    private Element makeLineString(Double startLatitude, Double startLongitude, Double stopLatitude, Double stopLongitude) {
        if (startLatitude == null || startLongitude == null || stopLatitude == null || stopLongitude == null) {
            return null;
        }

        Element lineString = new Element("LineString", ns); //NON-NLS
        lineString.addContent(new Element("extrude", ns).addContent("1")); //NON-NLS
        lineString.addContent(new Element("tessellate", ns).addContent("1")); //NON-NLS
        lineString.addContent(new Element("altitudeMode", ns).addContent("clampToGround")); //NON-NLS
        // KML uses lon, lat. Deliberately reversed.
        lineString.addContent(new Element("coordinates", ns).addContent(
                startLongitude + "," + startLatitude + ",0.0,"
                + stopLongitude + "," + stopLatitude + ",0.0")); //NON-NLS
        return lineString;
    }

    private Element makePlacemark(String name, FeatureColor color, String description, Long timestamp, Element feature, String coordinates) {
        Element placemark = new Element("Placemark", ns); //NON-NLS
        if (name != null && !name.isEmpty()) {
            placemark.addContent(new Element("name", ns).addContent(name)); //NON-NLS
        } else if (timestamp != null) {
            placemark.addContent(new Element("name", ns).addContent(getTimeStamp(timestamp))); //NON-NLS
        } else {
            placemark.addContent(new Element("name", ns).addContent("")); //NON-NLS
        }
        placemark.addContent(new Element("styleUrl", ns).addContent(color.getColor())); //NON-NLS
        placemark.addContent(new Element("description", ns).addContent(description)); //NON-NLS
        if (timestamp != null) {
            Element time = new Element("TimeStamp", ns); //NON-NLS
            time.addContent(new Element("when", ns).addContent(getTimeStamp(timestamp))); //NON-NLS
            placemark.addContent(time);
        }
        placemark.addContent(feature);
        if (coordinates != null && !coordinates.isEmpty()) {
            placemark.addContent(new Element("snippet", ns).addContent(coordinates)); //NON-NLS
        }
        return placemark;
    }

    private Element makePlacemarkWithPicture(String name, FeatureColor color, String description, Long timestamp, Element feature, Path path, String coordinates) {
        Element placemark = new Element("Placemark", ns); //NON-NLS
        Element desc = new Element("description", ns); //NON-NLS
        if (name != null && !name.isEmpty()) {
            placemark.addContent(new Element("name", ns).addContent(name)); //NON-NLS
            String image = "<img src='" + name + "' width='400'/>"; //NON-NLS
            desc.addContent(image);
        }
        placemark.addContent(new Element("styleUrl", ns).addContent(color.getColor())); //NON-NLS
        if (path != null) {
            String pathAsString = path.toString();
            if (pathAsString != null && !pathAsString.isEmpty()) {
                desc.addContent(description + "<b>Source Path:</b> " + pathAsString);
            }
        }
        placemark.addContent(desc);

        if (timestamp != null) {
            Element time = new Element("TimeStamp", ns); //NON-NLS
            time.addContent(new Element("when", ns).addContent(getTimeStamp(timestamp))); //NON-NLS
            placemark.addContent(time);
        }
        placemark.addContent(feature);
        if (coordinates != null && !coordinates.isEmpty()) {
            placemark.addContent(new Element("snippet", ns).addContent(coordinates)); //NON-NLS
        }
        return placemark;
    }

    private void copyFileUsingStream(AbstractFile inputFile, File outputFile) throws ReadContentInputStreamException, IOException {
        byte[] buffer = new byte[65536];
        int length;
        outputFile.createNewFile();
        try (InputStream is = new ReadContentInputStream(inputFile);
                OutputStream os = new FileOutputStream(outputFile)) {
            while ((length = is.read(buffer)) != -1) {
                os.write(buffer, 0, length);
            }
        }
    }

    @Override
    public String getName() {
        String name = NbBundle.getMessage(this.getClass(), "ReportKML.getName.text");
        return name;
    }

    @Override
    public String getRelativeFilePath() {
        return "ReportKML.kml"; //NON-NLS
    }

    @Override
    public String getDescription() {
        String desc = NbBundle.getMessage(this.getClass(), "ReportKML.getDesc.text");
        return desc;
    }

    @Override
    public JPanel getConfigurationPanel() {
        return null; // No configuration panel
    }

    private static String removeLeadingImgAndVol(String uniquePath) {
        // split the path into parts
        String[] pathSegments = uniquePath.replaceFirst("^/*", "").split("/"); //NON-NLS

        // Replace image/volume name if they exist in specific entries
        if (pathSegments.length > 0) {
            pathSegments[0] = pathSegments[0].replaceFirst("^img_", ""); //NON-NLS
        }
        if (pathSegments.length > 1) {
            pathSegments[1] = pathSegments[1].replaceFirst("^vol_", ""); //NON-NLS
        }

        // Assemble the path
        StringBuilder strbuf = new StringBuilder();
        for (String segment : pathSegments) {
            if (!segment.isEmpty()) {
                strbuf.append("/").append(segment);
            }
        }
        return strbuf.toString();
    }

    private String getFormattedDetails(Waypoint point, String header) {
        StringBuilder result = new StringBuilder(); //NON-NLS
        result.append(String.format("<h3>%s</h3>", header))
                .append(formatAttribute("Name", point.getLabel()));

        Long timestamp = point.getTimestamp();
        if (timestamp != null) {
            result.append(formatAttribute("Timestamp", getTimeStamp(timestamp)));
        }

        result.append(formatAttribute("Latitude", point.getLatitude().toString()))
                .append(formatAttribute("Longitude", point.getLongitude().toString()));

        if (point.getAltitude() != null) {
            result.append(formatAttribute("Altitude", point.getAltitude().toString()));
        }

        List<Waypoint.Property> list = point.getOtherProperties();
        for (Waypoint.Property prop : list) {
            String value = prop.getValue();
            if (value != null && !value.isEmpty()) {
                result.append(formatAttribute(prop.getDisplayName(), value));
            }
        }

        return result.toString();
    }

    private String formatAttribute(String title, String value) {
        return String.format(HTML_PROP_FORMAT, title, value);
    }

    private String getFormattedDetails(Route route) {
        List<Waypoint> points = route.getRoute();
        StringBuilder result = new StringBuilder(); //NON-NLS

        result.append(String.format("<h3>%s</h3>", Bundle.Route_Details_Header()))
                .append(formatAttribute("Name", route.getLabel()));

        Long timestamp = route.getTimestamp();
        if (timestamp != null) {
            result.append(formatAttribute("Timestamp", getTimeStamp(timestamp)));
        }

        if (points.size() > 1) {
            Waypoint start = points.get(0);
            Waypoint end = points.get(1);

            result.append(formatAttribute("Start Latitude", start.getLatitude().toString()))
                    .append(formatAttribute("Start Longitude", start.getLongitude().toString()));

            Double altitude = start.getAltitude();
            if (altitude != null) {
                result.append(formatAttribute("Start Altitude", altitude.toString()));
            }

            result.append(formatAttribute("End Latitude", end.getLatitude().toString()))
                    .append(formatAttribute("End Longitude", end.getLongitude().toString()));

            altitude = end.getAltitude();
            if (altitude != null) {
                result.append(formatAttribute("End Altitude", altitude.toString()));
            }
        }

        List<Waypoint.Property> list = route.getOtherProperties();
        for (Waypoint.Property prop : list) {
            String value = prop.getValue();
            if (value != null && !value.isEmpty()) {
                result.append(formatAttribute(prop.getDisplayName(), value));
            }
        }

        return result.toString();
    }

    private String formattedCoordinates(Double latitude, Double longitude) {
        if (latitude == null || longitude == null) {
            return "";
        }

        return String.format("%.2f, %.2f", latitude, longitude);
    }
    
    private boolean shouldFilterFromReport(Content content) throws TskCoreException {
        if(this.settings.getSelectedDataSources() == null) {
            return false;
        }
        long dataSourceId = content.getDataSource().getId();
        return !this.settings.getSelectedDataSources().contains(dataSourceId);
    }
}