/*******************************************************************************
 * Copyright (c) 2016 École Polytechnique de Montréal
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License 2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************/

package org.eclipse.tracecompass.statesystem.core.tests.stubs.backend;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;

import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.HTConfig;
import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.HistoryTreeBackend;
import org.eclipse.tracecompass.internal.statesystem.core.backend.historytree.IHistoryTree;

/**
 * Stub class for the {@link HistoryTreeBackend}. It creates a
 * {@link HistoryTreeClassicStub} to grant access to some protected methods.
 *
 * @author Geneviève Bastien
 */
public class HistoryTreeBackendStub extends HistoryTreeBackend {

    private static HistoryTreeType HT_TYPE = HistoryTreeType.CLASSIC;

    /**
     * Sets the type of tree to build. Since the history tree is initialized in
     * the parent's constructor, this stub class needs to know the type of tree
     * to build.
     *
     * @param htType
     *            The type of history tree to build for this backend
     */
    public static void setTreeType(HistoryTreeType htType) {
        HT_TYPE = htType;
    }

    /**
     * Enumeration of all history tree types implemented. This will be used to
     * create the right type of history tree
     */
    public enum HistoryTreeType {
        /**
         * The classic history tree
         */
        CLASSIC
    }

    /**
     * Constructor for new history files. Use this when creating a new history
     * from scratch.
     *
     * @param ssid
     *            The state system's ID
     * @param newStateFile
     *            The filename/location where to store the state history (Should
     *            end in .ht)
     * @param providerVersion
     *            Version of of the state provider. We will only try to reopen
     *            existing files if this version matches the one in the
     *            framework.
     * @param startTime
     *            The earliest time stamp that will be stored in the history
     * @param blockSize
     *            The size of the blocks in the history file. This should be a
     *            multiple of 4096.
     * @param maxChildren
     *            The maximum number of children each core node can have
     * @throws IOException
     *             Thrown if we can't create the file for some reason
     */
    public HistoryTreeBackendStub(String ssid,
            File newStateFile,
            int providerVersion,
            long startTime,
            int blockSize,
            int maxChildren) throws IOException {
        super(ssid, newStateFile, providerVersion, startTime, blockSize, maxChildren);
    }

    /**
     * Existing history constructor. Use this to open an existing state-file.
     *
     * @param ssid
     *            The state system's id
     * @param existingStateFile
     *            Filename/location of the history we want to load
     * @param providerVersion
     *            Expected version of of the state provider plugin.
     * @throws IOException
     *             If we can't read the file, if it doesn't exist, is not
     *             recognized, or if the version of the file does not match the
     *             expected providerVersion.
     */
    public HistoryTreeBackendStub(String ssid, File existingStateFile, int providerVersion)
            throws IOException {
        super(ssid, existingStateFile, providerVersion);
    }

    @Override
    protected IHistoryTree initializeSHT(HTConfig conf) throws IOException {
        switch (HT_TYPE) {
        case CLASSIC:
            return new HistoryTreeClassicStub(conf);
        default:
            return new HistoryTreeClassicStub(conf);
        }
    }

    @Override
    protected IHistoryTree initializeSHT(File existingStateFile, int providerVersion) throws IOException {
        switch (HT_TYPE) {
        case CLASSIC:
            return new HistoryTreeClassicStub(existingStateFile, providerVersion);
        default:
            return new HistoryTreeClassicStub(existingStateFile, providerVersion);
        }
    }

    /**
     * Get the History Tree built by this backend.
     *
     * @return The history tree
     */
    public HistoryTreeClassicStub getHistoryTree() {
        return (HistoryTreeClassicStub) super.getSHT();
    }

    /**
     * Debug method to print the contents of the history backend.
     *
     * @param writer
     *            The PrintWriter where to write the output
     */
    public void debugPrint(PrintWriter writer) {
        /* By default don't print out all the intervals */
        debugPrint(writer, false, -1);
    }

    /**
     * The basic debugPrint method will print the tree structure, but not their
     * contents.
     *
     * This method here print the contents (the intervals) as well.
     *
     * @param writer
     *            The PrintWriter to which the debug info will be written
     * @param printIntervals
     *            Should we also print every contained interval individually?
     * @param ts
     *            The timestamp that nodes have to intersect for intervals to be
     *            printed. A negative value will print intervals for all nodes.
     *            The timestamp only applies if printIntervals is true.
     */
    public void debugPrint(PrintWriter writer, boolean printIntervals, long ts) {
        /* Only used for debugging, shouldn't be externalized */
        writer.println("------------------------------"); //$NON-NLS-1$
        writer.println("State History Tree:\n"); //$NON-NLS-1$
        writer.println(getSHT().toString());
        writer.println("Average node utilization: " //$NON-NLS-1$
                + getAverageNodeUsage());
        writer.println(""); //$NON-NLS-1$

        getHistoryTree().debugPrintFullTree(writer, printIntervals, ts);
    }
}