/*
 *  Copyright 2021 Anyware Services
 *
 *  Licensed 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 org.ametys.runtime.plugins.admin.jvmstatus;

import java.lang.management.LockInfo;
import java.lang.management.ManagementFactory;
import java.lang.management.MonitorInfo;
import java.lang.management.ThreadMXBean;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;

import org.ametys.core.ui.Callable;
import org.ametys.core.util.DateUtils;

/**
 * Component used by the admin thread tool
 */
public class ThreadInfo implements Component
{
    /** Avalon role */
    public static final String ROLE = ThreadInfo.class.getName();
    
    private Pattern _groupPattern = Pattern.compile("^(.*)-\\d+$");

    /**
     * Create a threaddump
     * @return The new threaddump
     */
    @Callable(rights = "REPOSITORY_Rights_Access", context = "/admin")
    public Map<String, Object> getThreadDump()
    {
        StringBuffer threadDump = new StringBuffer (System.lineSeparator ());
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean ();
        for (java.lang.management.ThreadInfo threadInfo : threadMXBean.dumpAllThreads (true, true))
        {
            threadDump.append (_threadInfoToString(threadInfo));
        }
        return Map.of(
            "date", DateUtils.zonedDateTimeToString(ZonedDateTime.now()),
            "data", threadDump.toString().replaceAll("\r", "")
        );
    }
    
    /**
     * Dump all JVM threads.
     * @return a JSON-oriented thread dump
     */
    @Callable(rights = "REPOSITORY_Rights_Access", context = "/admin")
    public List<Map<String, Object>> dumpAllThreads()
    {
        List<Map<String, Object>> result = new ArrayList<>();
        
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        java.lang.management.ThreadInfo[] threads = threadMXBean.dumpAllThreads(true, true);
        
        for (java.lang.management.ThreadInfo thread : threads)
        {
            Map<String, Object> info = new HashMap<>();
            
            String name = thread.getThreadName();
            String group = "-";
            Matcher matcher = _groupPattern.matcher(name);
            if (matcher.matches())
            {
                group = matcher.group(1);
            }
            
            info.put("name", name);
            info.put("group", group);
            info.put("state", thread.getThreadState());
            info.put("cpu", threadMXBean.getThreadCpuTime(thread.getThreadId()));
            info.put("blocked-time", thread.getBlockedTime());
            info.put("waited-time", thread.getWaitedTime());
            info.put("lock-owner", thread.getLockOwnerName());
            
            String trace = Arrays.stream(thread.getStackTrace())
                                       .map(el -> _printStackTraceElement(el))
                                       .collect(Collectors.joining("\n"));
            info.put("stack-trace", trace);
            info.put("stack-ametys", Arrays.stream(thread.getStackTrace()).anyMatch(el -> el.getClassName().contains("org.ametys")));
            info.put("stack-size", thread.getStackTrace().length);
            
            result.add(info);
        }
        
        return result;
    }
    
    private String _printStackTraceElement(StackTraceElement el)
    {
        return el.getClassName() + "." + el.getMethodName() + "(" + (el.isNativeMethod() ? "Native Method)" : (el.getFileName() != null && el.getLineNumber() >= 0 ? el.getFileName() + ":" + el.getLineNumber() + ")" : (el.getFileName() != null ?  "" + el.getFileName() + ")" : "Unknown Source)")));
    }
    
    // Duplicated from java.lang.management.ThreadInfo#toString removing the MAX_FRAMES limit
    private String _threadInfoToString(java.lang.management.ThreadInfo threadInfo)
    {
        StringBuilder sb = new StringBuilder("\"" + threadInfo.getThreadName() + "\"" + (threadInfo.isDaemon() ? " daemon" : "") + " prio=" + threadInfo.getPriority() + " Id=" + threadInfo.getThreadId() + " " + threadInfo.getThreadState());
        if (threadInfo.getLockName() != null)
        {
            sb.append(" on " + threadInfo.getLockName());
        }
        if (threadInfo.getLockOwnerName() != null)
        {
            sb.append(" owned by \"" + threadInfo.getLockOwnerName() + "\" Id=" + threadInfo.getLockOwnerId());
        }
        if (threadInfo.isSuspended())
        {
            sb.append(" (suspended)");
        }
        if (threadInfo.isInNative())
        {
            sb.append(" (in native)");
        }
        sb.append('\n');
        
        StackTraceElement[] stackTrace = threadInfo.getStackTrace();
        
        int i = 0;
        for (; i < stackTrace.length; i++)
        {
            StackTraceElement ste = stackTrace[i];
            sb.append("\tat " + ste.toString());
            sb.append('\n');
            if (i == 0 && threadInfo.getLockInfo() != null)
            {
                Thread.State ts = threadInfo.getThreadState();
                switch (ts)
                {
                    case BLOCKED:
                        sb.append("\t-  blocked on " + threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    case WAITING:
                        sb.append("\t-  waiting on " + threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    case TIMED_WAITING:
                        sb.append("\t-  waiting on " + threadInfo.getLockInfo());
                        sb.append('\n');
                        break;
                    default:
                }
            }

            for (MonitorInfo mi : threadInfo.getLockedMonitors())
            {
                if (mi.getLockedStackDepth() == i)
                {
                    sb.append("\t-  locked " + mi);
                    sb.append('\n');
                }
            }
        }

        LockInfo[] locks = threadInfo.getLockedSynchronizers();
        if (locks.length > 0)
        {
            sb.append("\n\tNumber of locked synchronizers = " + locks.length);
            sb.append('\n');
            for (LockInfo li : locks)
            {
                sb.append("\t- " + li);
                sb.append('\n');
            }
        }
        sb.append('\n');
        return sb.toString();
    }
}