/*******************************************************************************
 * Copyright (c) 2013, 2014 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
 *
 * Contributors:
 *   Matthew Khouzam - Initial API and implementation
 *******************************************************************************/

package org.eclipse.tracecompass.internal.tmf.ui.project.wizards.importtrace;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;

/**
 * A helper class to show the trace types and files and names. it contains the
 * model which can be defined as follows : {tracetype -> { file1, file2, ... }
 * }+
 *
 * @author Matthew Khouzam
 */
class ImportTraceContentProvider implements ITreeContentProvider {

    private final Map<String, String> fTraceTypes = new HashMap<>();
    private final Map<String, Set<FileAndName>> fTraceFiles = new HashMap<>();
    private final List<String> fTraceTypesToScan;
    private final Set<String> fParentFilesToScan;

    public ImportTraceContentProvider(List<String> traceTypesToScan, Set<String> parentFilesToScan) {
        fTraceTypesToScan = traceTypesToScan;
        fParentFilesToScan = parentFilesToScan;
    }

    /**
     * Add a trace candidate to display
     *
     * @param traceTypeId
     *            the trace type id of the trace
     * @param traceToOpen
     *            the trace file.
     */
    public synchronized void addCandidate(String traceTypeId, File traceToOpen) {
        TraceTypeHelper traceTypeHelper = TmfTraceType.getTraceType(traceTypeId);
        if (traceTypeHelper == null) {
            return;
        }
        fTraceTypes.put(traceTypeHelper.getName(), traceTypeId);
        if (!fTraceFiles.containsKey(traceTypeId)) {
            fTraceFiles.put(traceTypeId, new TreeSet<FileAndName>());
        }
        final FileAndName traceFile = new FileAndName(traceToOpen, traceToOpen.getName());
        traceFile.setTraceTypeId(traceTypeId);
        final Set<FileAndName> categorySet = fTraceFiles.get(traceTypeId);
        categorySet.add(traceFile);
    }

    /**
     * Reset all the candidates
     */
    public synchronized void clearCandidates() {
        fTraceTypes.clear();
        fTraceFiles.clear();
    }

    @Override
    public void dispose() {
        fTraceFiles.clear();
        fTraceTypes.clear();

    }

    @Override
    public synchronized void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
        if (oldInput != newInput && newInput != null) {
            ImportTraceContentProvider input = (ImportTraceContentProvider) newInput;
            clearCandidates();
            fTraceTypes.putAll(input.fTraceTypes);
            fTraceFiles.putAll(fTraceFiles);
        }
    }

    @Override
    public synchronized Object[] getElements(Object inputElement) {
        List<String> candidates = new ArrayList<>();

        for (String candidate : fTraceTypesToScan) {
            for (Entry<String, String> entry : fTraceTypes.entrySet()) {
                if (entry.getValue().equals(candidate)) {
                    candidates.add(entry.getKey());
                    break;
                }
            }

        }
        return candidates.toArray(new String[candidates.size()]);
    }

    @Override
    public synchronized Object[] getChildren(Object parentElement) {
        if (parentElement instanceof String) {
            final Set<FileAndName> children = fTraceFiles.get(fTraceTypes.get(parentElement));
            if (children != null) {
                Set<FileAndName> candidates = new TreeSet<>();
                for (FileAndName child : children) {
                    for (String parent : fParentFilesToScan) {
                        // this is going to be slow, but less slow than UI
                        // display and should not be done for more than 10k
                        // elements.
                        if (child.getFile().getAbsolutePath().startsWith(parent)) {
                            candidates.add(child);
                        }
                    }
                }
                return candidates.toArray(new FileAndName[0]);
            }
        }
        return null;
    }

    /**
     * Gets the brothers and systems of a file element
     *
     * @param element
     *            the child leaf
     * @return the siblings of an element, including itself. Should never be
     *         null
     */
    public synchronized FileAndName[] getSiblings(FileAndName element) {
        String key = (String) getParent(element);
        return (FileAndName[]) getChildren(key);

    }

    @Override
    public synchronized Object getParent(Object element) {
        if (element instanceof FileAndName) {
            for (String key : fTraceFiles.keySet()) {
                Set<FileAndName> fanSet = fTraceFiles.get(key);
                if (fanSet.contains(element)) {
                    return key;
                }
            }
        }
        return null;
    }

    @Override
    public synchronized boolean hasChildren(Object element) {
        if (element instanceof String) {
            String key = (String) element;
            return fTraceFiles.containsKey(fTraceTypes.get(key));
        }
        return false;
    }

    /**
     * Gets the number of traces to import
     *
     * @return the number of traces to import
     */
    public synchronized int getSize() {
        int tot = 0;
        for (String s : fTraceFiles.keySet()) {
            tot += fTraceFiles.get(s).size();
        }
        return tot;
    }
}