/*******************************************************************************
 * Copyright (c) 2017 Ericsson
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.tracecompass.incubator.internal.uftrace.core.trace;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;

import org.apache.commons.io.FilenameUtils;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.tracecompass.analysis.os.linux.core.event.aspect.LinuxPidAspect;
import org.eclipse.tracecompass.analysis.os.linux.core.event.aspect.LinuxTidAspect;
import org.eclipse.tracecompass.incubator.internal.uftrace.core.Activator;
import org.eclipse.tracecompass.incubator.internal.uftrace.core.trace.SymParser.Symbol;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.event.ITmfEventType;
import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
import org.eclipse.tracecompass.tmf.core.event.aspect.TmfBaseAspects;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
import org.eclipse.tracecompass.tmf.core.project.model.ITmfPropertiesProvider;
import org.eclipse.tracecompass.tmf.core.symbols.ISymbolProvider;
import org.eclipse.tracecompass.tmf.core.symbols.ISymbolProviderFactory;
import org.eclipse.tracecompass.tmf.core.symbols.TmfResolvedSymbol;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceKnownSize;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceWithPreDefinedEvents;
import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TraceValidationStatus;
import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
import org.eclipse.tracecompass.tmf.core.trace.location.TmfLongLocation;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;

/**
 * Trace with the following data
 * <ul>
 * <li>info : various information about uftrace and running process</li>
 * <li>task.txt : task and session information</li>
 * <li>sid-<SESSION_ID>.map : memory mapping for a session</li>
 * <li>[PROGRAM].sym : (function) symbol address and name</li>
 * <li>[TID].dat : trace data for each task of given <TID></li>
 * <li>kernel_header : kernel ftrace header info (only if kernel tracing was
 * used)</li>
 * <li>kallsyms : kernel symbol information (ditto)</li>
 * <li>kernel-cpuX.dat : per-cpu kernel tracing data (ditto)</li>
 * </ul>
 *
 * @author Matthew Khouzam
 */
public class Uftrace extends TmfTrace implements ITmfPropertiesProvider,
        ITmfTraceKnownSize, ITmfTraceWithPreDefinedEvents {

    private Collection<DatParser> fDats = new ArrayList<>();
    private Map<Long, MapParser> fMap = new HashMap<>();
    private Map<String, SymParser> fSyms = new HashMap<>();
    private TaskParser fTasks;
    private TmfLongLocation fCurrentLoc = new TmfLongLocation(0L);
    private InfoParser fInfo;

    private long fSize;

    private final ISymbolProvider fSymbolProvider = new UfTraceSymbolProvider();

    private final @NonNull TidAspect fTidAspect = new TidAspect();
    private final @NonNull PidAspect fPidAspect = new PidAspect();
    private final @NonNull ExecAspect fExecAspect = new ExecAspect();
    private @Nullable String fHostId = null;

    @Override
    public Iterable<ITmfEventAspect<?>> getEventAspects() {
        return ImmutableList.of(TmfBaseAspects.getTimestampAspect(), TmfBaseAspects.getEventTypeAspect(),
                new ITmfEventAspect<Integer>() {

                    @Override
                    public String getName() {
                        return "depth"; //$NON-NLS-1$
                    }

                    @Override
                    public String getHelpText() {
                        return ""; //$NON-NLS-1$
                    }

                    @Override
                    public @Nullable Integer resolve(ITmfEvent event) {
                        Object fieldValue = event.getContent().getValue();
                        if (fieldValue instanceof DatEvent) {
                            return ((DatEvent) fieldValue).getDepth();
                        }
                        return null;
                    }
                }, new ITmfEventAspect<String>() {

                    @Override
                    public String getName() {
                        return "Address"; //$NON-NLS-1$
                    }

                    @Override
                    public String getHelpText() {
                        return ""; //$NON-NLS-1$
                    }

                    @Override
                    public @Nullable String resolve(ITmfEvent event) {
                        if (event.getContent().getValue() instanceof DatEvent) {
                            DatEvent datEvent = (DatEvent) event.getContent().getValue();
                            TmfResolvedSymbol symbol = fSymbolProvider.getSymbol(datEvent.getTid(), 0, datEvent.getAddress());
                            if (symbol != null) {
                                return symbol.getSymbolName();
                            }
                        }
                        return null;
                    }
                }, getTidAspect(), getPidAspect(), getExecAspect()

        );
    }

    @Override
    public IStatus validate(IProject project, String path) {
        File dir = new File(path);
        int confidence = 0;
        if (dir.isDirectory()) {
            confidence += 5;
            List<File> data = Arrays.asList(dir.listFiles());
            boolean hasDat = false;
            boolean hasMap = false;
            boolean hasSym = false;
            for (File file : data) {
                String extension = FilenameUtils.getExtension(file.getName());
                if (extension.equals("dat")) { //$NON-NLS-1$
                    try {
                        // TODO: Also support the perf-cpu data. For now, it
                        // does not contain uftrace data
                        if (file.getName().startsWith("perf-cpu")) { //$NON-NLS-1$
                            continue;
                        }
                        DatParser dp = new DatParser(file);
                        // read first event (really check magic number header)
                        dp.iterator().next();
                        confidence += 4;
                        hasDat = true;
                    } catch (IllegalArgumentException e) {
                        // we don't want a failing trace
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "dat parsing error", e); //$NON-NLS-1$
                    }

                }
                if (extension.equals("map")) { //$NON-NLS-1$
                    try {
                        if (MapParser.create(file) != null) {
                            confidence += 4;
                        }
                        hasMap = true;
                    } catch (IOException e) {
                        // we don't want a failing trace
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "map parsing error", e); //$NON-NLS-1$
                    }
                }
                if (extension.equals("sym")) { //$NON-NLS-1$
                    hasSym = true;
                    confidence += 3;
                }
            }
            if (hasMap && hasDat && hasSym && confidence > 10) {
                return new TraceValidationStatus(confidence, Activator.class.getCanonicalName());
            }
        }
        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Most probably not a UFTrace"); //$NON-NLS-1$
    }

    @Override
    public void initTrace(IResource resource, String path, Class<? extends ITmfEvent> type) throws TmfTraceException {
        File dir = new File(path);
        if (!dir.isDirectory()) {
            throw new TmfTraceException("trace is not a directory"); //$NON-NLS-1$
        }
        super.initTrace(resource, path, type);
        for (File child : dir.listFiles()) {
            String name = child.getName();
            try {
                if (name.endsWith(".dat")) { //$NON-NLS-1$
                    // TODO: Also support the perf-cpu data. For now, it does
                    // not contain uftrace data
                    if (name.startsWith("perf-cpu")) { //$NON-NLS-1$
                        continue;
                    }
                    fSize += child.length();
                    fDats.add(new DatParser(child));
                } else if (name.endsWith(".map")) { //$NON-NLS-1$
                    MapParser create = MapParser.create(child);
                    if (create != null) {
                        fMap.put(create.getSessionId(), create);
                    }
                } else if (name.endsWith(".sym")) { //$NON-NLS-1$
                    fSyms.put(name.substring(0, name.length() - 4), SymParser.parse(child));
                } else if (name.equals("task.txt")) { //$NON-NLS-1$
                    fTasks = new TaskParser(child);
                } else if (name.equals("info")) { //$NON-NLS-1$
                    fInfo = InfoParser.parse(child);
                } else if (name.equals("hostid")) { //$NON-NLS-1$
                    /*
                     * A 'hostid' file can be added which contains only one line
                     * with the host ID in it. This can be used to correlate
                     * with some other traces' data like an lttng kernel trace
                     */
                    List<String> fileLines = Files.readAllLines(child.toPath());
                    if (!fileLines.isEmpty()) {
                        fHostId = fileLines.get(0);
                    }
                }
            } catch (IOException e) {
                throw new TmfTraceException(e.getMessage(), e);
            }
        }
    }

    @Override
    public ITmfLocation getCurrentLocation() {
        return fCurrentLoc;
    }

    @Override
    public double getLocationRatio(ITmfLocation location) {
        return (long) location.getLocationInfo() / fSize;
    }

    @Override
    public ITmfContext seekEvent(ITmfLocation location) {
        UfContext context = new UfContext(fDats, this);
        if (location == null) {
            return context;
        }
        if (location instanceof TmfLongLocation) {
            TmfLongLocation longLocation = (TmfLongLocation) location;
            if (longLocation.getLocationInfo().longValue() == 0) {
                return context;
            }
            while (context.getLocation() != null && Long.compare(longLocation.getLocationInfo(), Objects.requireNonNull(context.getLocation()).getLocationInfo()) >= 0) {
                ITmfEvent next = context.getNext();
                if (next == null) {
                    break;
                }
                updateAttributes(context, next);
                if (context.getLocation() == null) {
                    return context;
                }
            }
        }
        return context;
    }

    @Override
    public ITmfContext seekEvent(double ratio) {
        return seekEvent(new TmfLongLocation((long) (ratio * fSize)));
    }

    @Override
    public ITmfEvent parseEvent(@Nullable ITmfContext ctx) {
        ITmfContext context = ctx;
        if (context == null) {
            context = seekEvent(0);
        }
        if (ctx instanceof UfContext) {
            UfContext ufContext = (UfContext) ctx;
            ITmfEvent tmfEvent = ufContext.getNext();
            if (tmfEvent != null) {
                fCurrentLoc = new TmfLongLocation(fCurrentLoc.getLocationInfo() + Long.BYTES * 2);
                ctx.setLocation(fCurrentLoc);
                updateAttributes(context, tmfEvent);
                return tmfEvent;
            }
        }
        return null;
    }

    @Override
    public Set<@NonNull ? extends ITmfEventType> getContainedEventTypes() {
        return UfEventType.TYPES;
    }

    @Override
    public int size() {
        return (int) (fSize / 1024);
    }

    @Override
    public int progress() {
        return (int) (fCurrentLoc.getLocationInfo() / 1024);
    }

    @Override
    public @NonNull String getHostId() {
        if (fHostId != null) {
            return fHostId;
        }
        return super.getHostId();
    }

    /**
     * Get the symbol provider for this trace
     *
     * @return the symbol provider
     */
    public ISymbolProvider getSymbolProvider() {
        return fSymbolProvider;
    }

    /**
     * TID aspect for UFTrace
     *
     * @author Matthew Khouzam
     */
    public final class TidAspect extends LinuxTidAspect {
        @Override
        public @Nullable Integer resolve(ITmfEvent event) {
            if (event.getContent().getValue() instanceof DatEvent) {
                DatEvent datEvent = (DatEvent) event.getContent().getValue();
                return datEvent.getTid();
            }
            return null;
        }
    }

    /**
     * PID aspect for UFTrace
     *
     * @author Matthew Khouzam
     */
    public final class PidAspect extends LinuxPidAspect {
        @Override
        public @Nullable Integer resolve(ITmfEvent event) {
            if (event.getContent().getValue() instanceof DatEvent) {
                DatEvent datEvent = (DatEvent) event.getContent().getValue();
                int tid = datEvent.getTid();
                return fTasks.getPid(tid);
            }
            return null;
        }
    }

    /**
     * Executable name aspect for UFTrace
     *
     * @author Matthew Khouzam
     */
    public final class ExecAspect implements ITmfEventAspect<String> {
        @Override
        public @NonNull String getName() {
            return "Executable"; //$NON-NLS-1$
        }

        @Override
        public @NonNull String getHelpText() {
            return ""; //$NON-NLS-1$
        }

        @Override
        public @Nullable String resolve(@NonNull ITmfEvent event) {
            if (event.getContent().getValue() instanceof DatEvent) {
                DatEvent datEvent = (DatEvent) event.getContent().getValue();
                int tid = datEvent.getTid();
                return fTasks.getExecName(tid);
            }
            return null;
        }
    }

    /**
     * Alleged symbol provider factory
     *
     * @author Matthew Khouzam
     *
     */
    public static class UfTraceSymbolProviderAllegedFactory implements ISymbolProviderFactory {

        @Override
        public @Nullable ISymbolProvider createProvider(@NonNull ITmfTrace trace) {
            if (trace instanceof Uftrace) {
                return ((Uftrace) trace).getSymbolProvider();
            }
            return null;
        }
    }

    @Override
    public @NonNull Map<@NonNull String, @NonNull String> getProperties() {
        if(fInfo == null) {
            return Collections.emptyMap();
        }
        Map<@NonNull String, @NonNull String> properties = new LinkedHashMap<>();
        properties.put("version", String.valueOf(fInfo.getVersion())); //$NON-NLS-1$
        properties.put("address length", String.valueOf(fInfo.getAddressSize())); //$NON-NLS-1$
        properties.put("endianness", String.valueOf(fInfo.getByteOrder())); //$NON-NLS-1$
        properties.put("maximum depth", String.valueOf(fInfo.getMaxDepth())); //$NON-NLS-1$
        properties.put("feature bit mask", Long.toBinaryString(fInfo.getFeatures())); //$NON-NLS-1$
        String hostId = fHostId;
        if (hostId != null) {
            properties.put("host ID", hostId); //$NON-NLS-1$
        }
        properties.putAll(fInfo.getData());
        return properties;
    }

    /**
     * get the tasks parser
     *
     * @return The tasks parser
     */
    public TaskParser getTasks() {
        return fTasks;
    }

    /**
     * Get the aspect to retrieve the executable name from a uftrace event
     *
     * @return The executable name aspect
     */
    public @NonNull ExecAspect getExecAspect() {
        return fExecAspect;
    }

    /**
     * Get the aspect to retrieve the PID of a uftrace event
     *
     * @return the pid aspect
     */
    public @NonNull PidAspect getPidAspect() {
        return fPidAspect;
    }

    /**
     * Get the aspect to retrieve the TID of a uftrace event
     *
     * @return the TID aspect
     */
    public @NonNull TidAspect getTidAspect() {
        return fTidAspect;
    }

    /**
     * overly complicated, should clean up
     *
     * @author Matthew Khouzam
     *
     */
    private class UfTraceSymbolProvider implements ISymbolProvider {
        @Override
        public TmfResolvedSymbol getSymbol(int tid, long timestamp, long address) {
            String execName = fTasks.getExecName(tid);
            if (execName == null) {
                return new TmfResolvedSymbol(address, "0x" + Long.toHexString(address)); //$NON-NLS-1$
            }
            Long session = fTasks.getSessName(tid);
            if (session == null) {
                return new TmfResolvedSymbol(address, "0x" + Long.toHexString(address)); //$NON-NLS-1$
            }
            MapParser mapParser = fMap.get(session);
            if (mapParser == null) {
                return new TmfResolvedSymbol(address, "0x" + Long.toHexString(address)); //$NON-NLS-1$
            }
            Entry<Long, MapEntry> key = mapParser.getData().floorEntry(address);
            if (key == null) {
                return new TmfResolvedSymbol(address, "0x" + Long.toHexString(address)); //$NON-NLS-1$
            }
            long offset = address - key.getValue().getAddrLow();
            String pathName = key.getValue().getPathName();
            String substring = pathName.substring(pathName.lastIndexOf(File.separator) + 1);
            SymParser sym = fSyms.get(substring);
            if (sym == null) {
                return new TmfResolvedSymbol(address, pathName + ":0x" + Long.toHexString(address)); //$NON-NLS-1$
            }
            Entry<Long, Symbol> floorEntry = sym.getMap().floorEntry(offset);
            if (floorEntry != null) {
                Symbol value = floorEntry.getValue();
                if (value != null) {
                    String name = String.valueOf(value.getName());
                    return new TmfResolvedSymbol(address, name);
                }
            }
            return new TmfResolvedSymbol(address, "0x" + Long.toHexString(address)); //$NON-NLS-1$
        }

        /* needed for ISymbolProvider */
        @Override
        public @NonNull ITmfTrace getTrace() {
            return (ITmfTrace) this;
        }

        @Override
        public void loadConfiguration(@Nullable IProgressMonitor monitor) {
            // do nothing
        }

        @Override
        public @Nullable TmfResolvedSymbol getSymbol(long address) {
            return getSymbol(Iterables.getFirst(fTasks.getTids(), -1), 0, address);
        }

    }

}