/**
 * Logback: the reliable, generic, fast and flexible logging framework.
 * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
 *
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *
 *   or (per the licensee's choosing)
 *
 * under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation.
 */
package chapters.appenders;

import org.slf4j.Logger;

import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.FileAppender;
import ch.qos.logback.core.encoder.EchoEncoder;

public class IO extends Thread {
    static String msgLong = "ABCDEGHIJKLMNOPQRSTUVWXYZabcdeghijklmnopqrstuvwxyz1234567890";
    static String msgShort = "Hello";
    static boolean scarceCPU;
    static int numThreads;
    static long l;
    static boolean longMessage;
    long len;
    boolean buffered;
    boolean immediateFlush;
    Logger logger;
    LoggerContext context;
    double throughput;

    public IO(boolean _buffered, boolean _immediateFlush, long _len) {
        this.len = _len;
        this.buffered = _buffered;
        this.immediateFlush = _immediateFlush;
        context = new LoggerContext();
        logger = context.getLogger("logger-" + getName());

        // A FileAppender is created according to the buffering and
        // immediate flush setting of this IO instance.
        FileAppender<ILoggingEvent> fa = new FileAppender<ILoggingEvent>();

        if (longMessage) {
            PatternLayoutEncoder pa = new PatternLayoutEncoder();
            pa.setPattern("%r %5p %c [%t] - %m%n");
            pa.setContext(context);
            pa.start();
            fa.setEncoder(pa);
        } else {
            fa.setEncoder(new EchoEncoder<ILoggingEvent>());
        }

        fa.setFile(getName() + ".log");
        fa.setAppend(false);
        fa.setContext(context);
        fa.start();

    }

    public static void main(String[] argv) throws Exception {
        if (argv.length != 4) {
            usage("Wrong number of arguments.");
        }

        l = Integer.parseInt(argv[0]);
        numThreads = Integer.parseInt(argv[1]);
        scarceCPU = "true".equalsIgnoreCase(argv[2]);
        longMessage = "long".equalsIgnoreCase(argv[3]);

        // ----------------------------------------------------
        // first test with unbuffered IO and immediate flushing
        perfCase(false, true, l);

        // ----------------------------------------------------
        // Second test with unbuffered IO and no immediate flushing
        perfCase(false, false, l);

        // ----------------------------------------------------
        // Third test with buffered IO and no immediate flushing
        perfCase(true, false, l);

        // There is no fourth test as buffered IO and immediate flushing
        // do not make sense.
    }

    static void usage(String msg) {
        System.err.println(msg);
        System.err.println("Usage: java " + IO.class.getName() + " runLength numThreads scarceCPU (short|long)\n"
                        + "   runLength (integer) the number of logs to generate perthread\n" + "   numThreads (integer) the number of threads.\n"
                        + "   scarceCPU (boolean) if true an additional CPU intensive thread is created\n" + "   (short|long) length of log messages.");
        System.exit(1);
    }

    static void perfCase(boolean buffered, boolean immediateFlush, long len) throws Exception {
        IO[] threads = new IO[numThreads];
        Counter counterThread = null;

        if (scarceCPU) {
            counterThread = new Counter();
            counterThread.start();
        }

        // First create the threads
        for (int i = 0; i < numThreads; i++) {
            threads[i] = new IO(buffered, immediateFlush, len);
        }

        // then start them
        for (int i = 0; i < numThreads; i++) {
            threads[i].start();
        }

        // wait for them to processPriorToRemoval, compute the average throughput
        double sum = 0;

        for (int i = 0; i < numThreads; i++) {
            threads[i].join();
            sum += threads[i].throughput;
        }

        if (scarceCPU) {
            // setting the interrupted field will cause counterThread to processPriorToRemoval
            counterThread.interrupted = true;
            counterThread.join();
        }

        System.out.println("On average throughput of " + (sum / numThreads) * 1000 + " logs per microsecond.");
        System.out.println("------------------------------------------------");
    }

    public void run() {
        String msg = msgShort;

        if (longMessage) {
            msg = msgLong;
        }

        long before = System.nanoTime();

        for (int i = 0; i < len; i++) {
            logger.debug(msg);
        }

        throughput = (len * 1.0) / (System.nanoTime() - before);
        System.out.println(getName() + ", buffered: " + buffered + ", immediateFlush: " + immediateFlush + ", throughput: " + throughput
                        + " logs per nanosecond.");
    }
}

class Counter extends Thread {
    public boolean interrupted = false;
    public double counter = 0;

    public void run() {
        long before = System.nanoTime();

        while (!interrupted) {
            if (counter % 1000 == 0) {
                Thread.yield();
            }
            counter += 1.0;
        }

        double tput = (counter * 1.0) / (System.nanoTime() - before);
        System.out.println("Counter thread " + getName() + " incremented counter by " + tput + " per nanosecond.");
    }
}