package test.common;

import org.apache.log4j.Logger;
import sun.management.VMManagement;

import java.io.BufferedWriter;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
class CustomLogger extends Logger {
    protected CustomLogger(String name) {
        super(name);
    }

    public static void LogError(String s, Object o) {
    }
}
public class JavaLoggingMultiThTest {

    public int pid;

    private class LoggerTask implements Callable<LoggerTask> {
        public synchronized void run() {
            int logMsgWrittenPerThread;
            int maxLogMsgsPerThread = 52224;
            for(logMsgWrittenPerThread = 1; logMsgWrittenPerThread <= maxLogMsgsPerThread; logMsgWrittenPerThread++) {
                CustomLogger.LogError("p:" + pid + ", LM:" + Integer.toString(logMsgWrittenPerThread), null);
            }
        }

        @Override public synchronized LoggerTask call()  {
            run();
            return this;
        }
    }

    public synchronized void runLoggerTaskMultipleThreads() {
        int numThreads = 20;
        ArrayList<LoggerTask> loggerTaskList = new ArrayList<LoggerTask>();
        for(int i=0; i< numThreads; i++) {
            loggerTaskList.add(new LoggerTask());
        }
        ExecutorService pool = Executors.newFixedThreadPool(numThreads);
        try {
            Instant startTS = Instant.now();
            List<Future<LoggerTask>> waiters = pool.invokeAll(loggerTaskList);
            boolean allEnded = false;
            for (Future waiter : waiters) {
                try {
                    waiter.get();
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
            do {
                try {
                    pool.shutdown();
                    allEnded = pool.awaitTermination(1, TimeUnit.MINUTES);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("Interrupted, for some reason");
                }
                if (!allEnded)
                    System.out.println("Not ending cleanly");
            } while (!allEnded);
            Instant endTS = Instant.now();
            Duration elapsed = Duration.between(startTS, endTS);
            System.out.println("Time taken by current process" + elapsed);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static int getCurrrentProcessId() throws Exception {

        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        Field jvm = runtime.getClass().getDeclaredField("jvm");
        jvm.setAccessible(true);

        VMManagement management = (VMManagement) jvm.get(runtime);
        Method method = management.getClass().getDeclaredMethod("getProcessId");
        method.setAccessible(true);

        return (Integer) method.invoke(management);
    }
    public static void main(String[] args) throws IOException {

        BufferedWriter writer = Files.newBufferedWriter(Paths.get("${user.home}\\log4j-multithreading-test.log"));
        writer.write("");
        writer.flush();

        JavaLoggingMultiThTest javaLoggingMultiThTest = new JavaLoggingMultiThTest();
        try {
            javaLoggingMultiThTest.pid = getCurrrentProcessId();
        } catch (Exception e) {
            e.printStackTrace();
        }
        javaLoggingMultiThTest.runLoggerTaskMultipleThreads();
    }
}