/*
 * Copyright 2012 The Netty Project

 *
 * The Netty Project licenses this file to you 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 io.netty.test.udt.util;

import com.google.caliper.ConfiguredBenchmark;
import com.google.caliper.Environment;
import com.google.caliper.EnvironmentGetter;
import com.google.caliper.Json;
import com.google.caliper.Result;
import com.google.caliper.Run;
import com.google.caliper.Runner;
import com.google.caliper.Scenario;
import com.google.caliper.ScenarioResult;
import com.google.caliper.SimpleBenchmark;
import com.yammer.metrics.core.TimerContext;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * Custom caliper runner for {@link CaliperBench}.
 */
public final class CaliperRunner {

    private static final InternalLogger log = InternalLoggerFactory.getInstance(CaliperRunner.class);

    private CaliperRunner() {
    }

    /**
     * Parse bench parameters.
     */
    public static List<String> valueList(final String valueText) {
        return Arrays.asList(valueText.split(","));
    }

    /**
     * Execute full cycle: warm up, execute and publish benchmark.
     */
    public static void execute(final Class<? extends CaliperBench> klaz)
            throws Exception {
        execute("WARMUP", klaz);
        Run run = execute("REPORT", klaz);
        publish(newResult(run));
    }

    /**
     * Execute benchmark for all parameter combinations.
     */
    public static Run execute(final String name,
            final Class<? extends CaliperBench> klaz) throws Exception {

        final CaliperBench booter = klaz.newInstance();

        final List<Map<String, String>> varsSet = product(booter);

        final Run run = newRun(klaz.getName());

        int index = 0;
        for (final Map<String, String> vars : varsSet) {
            final int done = 100 * index++ / varsSet.size();

            log.info("{} {}% {}", name, done, vars);

            /** call setUp() */
            final ConfiguredBenchmark runner = booter.createBenchmark(vars);

            final CaliperBench bench = (CaliperBench) runner.getBenchmark();
            final CaliperMeasure measure = bench.measure();
            measure.variables().putAll(vars);

            /** call timeXXX() */
            runner.run(0);

            /** call tearDown() */
            runner.close();

            measure.appendTo(run);
        }

        return run;
    }

    /**
     * Convert caliper result into JSON string.
     */
    public static String json(final Result result) {
        return Json.getGsonInstance().toJson(result);
    }

    /**
     * Map signature based on map values.
     */
    public static String signature(final Map<String, String> map) {
        final StringBuilder text = new StringBuilder();
        for (final String item : map.values()) {
            text.append(String.format("%20s", item));
        }
        return text.toString();
    }

    /**
     * Generate all parameter combinations for {@link SimpleBenchmark}.
     */
    public static List<Map<String, String>> product(final SimpleBenchmark bench) {
        final Set<Map<String, String>> collect = new HashSet<Map<String, String>>();
        final Map<String, Set<String>> pending = new TreeMap<String, Set<String>>();
        for (final String name : new TreeSet<String>(bench.parameterNames())) {
            pending.put(name, bench.parameterValues(name));
        }
        final List<Map<String, String>> list = new ArrayList<Map<String, String>>(
                product(collect, pending));
        final Comparator<Map<String, String>> comp = new Comparator<Map<String, String>>() {
            @Override
            public int compare(final Map<String, String> o1,
                    final Map<String, String> o2) {
                return signature(o1).compareTo(signature(o2));
            }
        };
        Collections.sort(list, comp);
        return list;
    }

    /**
     * Calculate ordered Cartesian product of sets.
     */
    public static Set<Map<String, String>> product(
            final Set<Map<String, String>> collect,
            final Map<String, Set<String>> pending) {

        if (pending.isEmpty()) {
            return collect;
        }

        final Set<Map<String, String>> extract = new HashSet<Map<String, String>>();
        final String key = pending.keySet().iterator().next();
        for (final String value : pending.remove(key)) {
            final Map<String, String> map = new TreeMap<String, String>();
            map.put(key, value);
            extract.add(map);
        }

        if (collect.isEmpty()) {
            collect.addAll(extract);
            return product(collect, pending);
        } else {
            final Set<Map<String, String>> inject = new HashSet<Map<String, String>>();
            for (final Map<String, String> mapExtr : extract) {
                for (final Map<String, String> mapColl : collect) {
                    final Map<String, String> mapProd = new TreeMap<String, String>();
                    mapProd.putAll(mapExtr);
                    mapProd.putAll(mapColl);
                    inject.add(mapProd);
                }
            }
            return product(inject, pending);
        }
    }

    /**
     * Publish result on http://microbenchmarks.appspot.com
     */
    public static void publish(final Result result) throws Exception {
        final Runner runner = new Runner();
        final Method method = runner.getClass().getDeclaredMethod(
                "postResults", Result.class);
        method.setAccessible(true);
        method.invoke(runner, result);
    }

    /**
     * Provide new named run instance.
     */
    public static Run newRun(final String benchmarkName) {
        final Map<Scenario, ScenarioResult> measurements = new HashMap<Scenario, ScenarioResult>();
        final Date executedTimestamp = new Date();
        return new Run(measurements, benchmarkName, executedTimestamp);
    }

    /**
     * Make new result from run.
     */
    public static Result newResult(final Run run) {
        final Environment env = new EnvironmentGetter().getEnvironmentSnapshot();
        return new Result(run, env);
    }

    /**
     * Verify measure publication manually.
     */
    public static void main(final String[] args) throws Exception {
        final Run run = newRun("test-main");
        for (int param = 0; param < 5; param++) {
            final CaliperMeasure measure = new CaliperMeasure();
            measure.variables().put("param", String.valueOf(param));
            for (int step = 0; step < 5; step++) {
                measure.rate().mark(50 + step);
                final TimerContext time = measure.time().time();
                Thread.sleep(15);
                time.stop();
                measure.size().value(50 + step);
                measure.mark();
            }
            measure.appendTo(run);
        }
        final Result result = newResult(run);
        publish(result);
        System.out.println(json(result));
    }

}
