import edu.rice.hj.api.HjMetrics;
import edu.rice.hj.api.HjRunnable;
import edu.rice.hj.runtime.config.HjSystemProperty;
import edu.rice.hj.runtime.metrics.AbstractMetricsManager;

import static edu.rice.hj.Module1.*;

/**
 * Reads in two strings, the pattern and the input text, and
 * searches for the pattern in the input text.
 * <p>
 * % hj Search rabrabracad abacadabrabracabracadabrabrabracad
 * text:    abacadabrabracabracadababacadabrabracabracadabrabrabracad
 * pattern:                                               rabrabracad
 * <p>
 * HJ version ported from Java version in http://algs4.cs.princeton.edu/53substring/Brute.java.html
 *
 * @author Vivek Sarkar (vsarkar@rice.edu)
 */
public class Search {
    private static final String default_pat = "ab";
    private static final String default_txt = "abracadabra";

    // return number of occurrences of pattern in text
    public static boolean searchSeq(final char[] pattern, final char[] text) {
        final int M = pattern.length;
        final int N = text.length;
        // Use an array of length 1 to box a boolean value
        final boolean[] found = {false};

        for (int i = 0; i <= N - M; i++) {
            int j;
            for (j = 0; j < M; j++) {
                doWork(1); // Count each char comparison as 1 unit of work
                if (text[i + j] != pattern[j]) {
                    break;
                }
            }
            if (j == M) {
                found[0] = true;
            }
        }
        return found[0];
    }

    // return number of occurrences of pattern in text
    public static boolean searchPar(final char[] pattern, final char[] text) {
        final int M = pattern.length;
        final int N = text.length;
        // Use an array of length 1 to box a boolean value
        final boolean[] found = {false};

        for (int i = 0; i <= N - M; i++) {
            int j;
            for (j = 0; j < M; j++) {
                doWork(1); // Count each char comparison as 1 unit of work
                if (text[i + j] != pattern[j]) {
                    break;
                }
            }
            if (j == M) {
                found[0] = true;
            }
        }
        return found[0];
    }

    public static HjMetrics kernel(final HjRunnable functionCall) {

        System.setProperty(HjSystemProperty.abstractMetrics.propertyKey(), "true");
        initializeHabanero();

        finish(functionCall::run);

        final HjMetrics actualMetrics = abstractMetrics();

        finalizeHabanero();

        return actualMetrics;

    }

    // test client
    public static void main(final String[] args) {

        final String pat = args.length >= 1 ? args[0] : default_pat;
        final String txt = args.length >= 2 ? args[1] : default_txt;

        System.out.println("text:    " + txt);
        System.out.println("pattern: " + pat);

        final char[] pattern = pat.toCharArray();
        final char[] text = txt.toCharArray();

        System.out.println();
        System.out.println("Running SEQUENTIAL: ");
        System.out.println("--------------------");
        final HjMetrics seqMetrics = kernel(() -> {
            final boolean seqFound = searchSeq(pattern, text);
            System.out.println("Pattern found by sequential algorithm: " + seqFound);
        });

        System.out.println();
        System.out.println("Running PARALLEL: ");
        System.out.println("--------------------");
        final HjMetrics parMetrics = kernel(() -> {
            final boolean parFound = searchPar(pattern, text);
            System.out.println("Pattern found by parallel algorithm: " + parFound);
        });

        System.out.println();
        System.out.println("SEQUENTIAL Metrics: ");
        System.out.println("--------------------");
        AbstractMetricsManager.dumpStatistics(seqMetrics);

        System.out.println();
        System.out.println("PARALLEL Metrics: ");
        System.out.println("--------------------");
        AbstractMetricsManager.dumpStatistics(parMetrics);

        final long seqWork = seqMetrics.totalWork();
        final long parCpl = parMetrics.criticalPathLength();
        final double actualParallelism = (1.0 * seqWork) / parCpl;
        System.out.println("====================");
        System.out.printf("IDEAL SPEED-UP = %.4f \n", actualParallelism);
    }
}