package art.servers.controller;

import art.library.model.devices.DeviceStatus;
import art.library.model.devices.application.Application;
import art.library.model.devices.application.ApplicationAlarms;
import art.library.model.devices.application.ApplicationInformation;
import art.library.model.devices.application.ApplicationStatus;
import art.library.model.devices.application.status.ApplicationStatusMemory;
import art.library.model.devices.application.status.ApplicationStatusOperatingSystem;
import art.library.model.devices.application.status.ApplicationStatusRuntime;
import art.library.model.devices.application.status.ApplicationStatusThread;
import art.library.utils.synchro.Mutex;
import art.servers.Shared;
import com.sun.management.OperatingSystemMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.RuntimeMXBean;
import java.lang.management.ThreadMXBean;
import javax.management.MBeanServerConnection;



public class ControllerStatus extends Controller
{
    private Application application = null;
    private Mutex mutexPersistance = new Mutex();
    
    public ControllerStatus(Application application)
    {
        this.setName("Controller status");
        this.application = application;
        
        try
        {
            ApplicationStatus status = (ApplicationStatus)this.application.getDeviceStatus();
            status.started = System.currentTimeMillis();
        }
        catch (Exception e)
        {
        }

    }
    
    
    
    public Application getApplication()
    {
        return application;
    }
    
    

    
    public int getAlarms()
    {
        try
        {
           return 0;
        }
        catch (Exception e)
        {
        }

        return DeviceStatus.STATUS_UNKNOWN;
    }    
    
    
    
    
    public void run()
    {
        try
        {
            // Get the stored timeless application if exists
            // If not we use the application from process configuration file 

            Application[] timelessApplication = Shared.model.getApplication(0);
            application.information = timelessApplication[0].information;
        }
        catch (Exception e)
        {
        }
                
        
        Shared.traceInformation(getName(), "Starting");
        
        long lastTimestamp = System.currentTimeMillis();
        
        while ((isInterrupted() == false) && (exit == false))
        {
            
            // Update current process information
            
            lastTimestamp = System.currentTimeMillis();

            memoryMXBean(application, lastTimestamp);
            threadMXBean(application, lastTimestamp);
            runtimeMXBean(application, lastTimestamp);
            operatingSystemMXBean(application, lastTimestamp);
            updateAlarms(application, lastTimestamp);
            application.setAlarm("alarm_offline", false);

            if (application.getLastTimestampStatusUpdate() > lastTimestamp)
            {
                application.setLastTimestampStatusUpdate(application.getLastTimestampStatusUpdate() + 1);
            }
            else
            {
                application.setLastTimestampStatusUpdate(lastTimestamp);
            }

            if (application.getLastTimestampUpdate() > lastTimestamp)
            {
                application.setLastTimestampUpdate(application.getLastTimestampUpdate() + 1);
            }
            else
            {
                application.setLastTimestampUpdate(lastTimestamp);
            }

            updatePersistence(application);

            
            long timetowait = application.getDeviceInformation().hearbeat -(System.currentTimeMillis() - lastTimestamp);

            if (timetowait > 0)
            {
                try
                {
                    sleep(timetowait);
                }
                catch (Exception e)
                {
                }
            }
        }
        
        Shared.traceInformation(getName(), "Finishing");
    }

    

    
    
    
        
    private void updatePersistence(Application application)
    {
        mutexPersistance.lockWrite();
        
        try
        {
            Shared.model.updateApplication(application);        
        }
        catch (Exception e)
        {
        }
        finally
        {
            mutexPersistance.releaseWrite();
        }
    }    


    
    
    
    private void memoryMXBean(Application application, long timestamp)
    {
        try
        {
            MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
            ApplicationStatus status = application.getDeviceStatus();
            if (status.memory == null) status.memory = new ApplicationStatusMemory();
            status.memory.timestamp = timestamp;

            MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
            MemoryUsage nonheapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
            
            status.memory.heapMemoryUsage_init = heapMemoryUsage.getInit();
            status.memory.heapMemoryUsage_max = heapMemoryUsage.getMax();
            status.memory.heapMemoryUsage_used = heapMemoryUsage.getUsed();
            status.memory.heapMemoryUsage_committed = heapMemoryUsage.getCommitted();
            
            status.memory.nonheapMemoryUsage_init = nonheapMemoryUsage.getInit();
            status.memory.nonheapMemoryUsage_max = nonheapMemoryUsage.getMax();
            status.memory.nonheapMemoryUsage_used = nonheapMemoryUsage.getUsed();
            status.memory.nonheapMemoryUsage_committed = nonheapMemoryUsage.getCommitted();
            
         }
        catch (Exception e)
        {
        }
    }
    
    
    
    
    private void threadMXBean(Application application, long timestamp)
    {
        try
        {
            ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
            ApplicationStatus status = application.getDeviceStatus();
            if (status.thread == null) status.thread = new ApplicationStatusThread();
            status.thread.timestamp = timestamp;

            
            long[] threadsid = threadMXBean.getAllThreadIds();

            long threadCpuTime = 0;
            long threadUserTime = 0;

            for (long threadid : threadsid)
            {
                try
                {   
                    long currentThreadCpuTime = threadMXBean.getThreadCpuTime(threadid);
                    long currentThreadUserTime = threadMXBean.getThreadUserTime(threadid);
                    if (currentThreadCpuTime > 0) threadCpuTime = threadCpuTime + currentThreadCpuTime;
                    if (currentThreadUserTime > 0) threadUserTime = threadUserTime + currentThreadUserTime;
                }
                catch (Exception e)
                {
                }
            }
            
            status.thread.totalStartedThreadCount = threadMXBean.getTotalStartedThreadCount();
            status.thread.threadCount = threadMXBean.getThreadCount();
            status.thread.peakThreadCount = threadMXBean.getPeakThreadCount();
            status.thread.daemonThreadCount = threadMXBean.getDaemonThreadCount();
            
        }
        catch (Exception e)
        {
        }
    }
    
    
    
    private void runtimeMXBean(Application application, long timestamp)
    {
        try
        {
            RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
            ApplicationStatus status = application.getDeviceStatus();
            if (status.runtime == null) status.runtime = new ApplicationStatusRuntime();
            status.runtime.timestamp = timestamp;

            status.runtime.startTime = runtimeMXBean.getStartTime();
            status.runtime.upTime = runtimeMXBean.getUptime();
            status.runtime.userTimeZone = runtimeMXBean.getSystemProperties().get("os.timezone");
            status.runtime.javaVmSpecificationVersion = runtimeMXBean.getSystemProperties().get("java.vm.specification.version");
            status.runtime.javaRuntimeVersion = runtimeMXBean.getSystemProperties().get("java.runtime.version");
            status.runtime.javaClassVersion = runtimeMXBean.getSystemProperties().get("java.class.version");
            status.runtime.userCountry = runtimeMXBean.getSystemProperties().get("user.country");
            status.runtime.userLanguage = runtimeMXBean.getSystemProperties().get("user.language");
            status.runtime.userTimeZone = runtimeMXBean.getSystemProperties().get("user.timezone");
         }
        catch (Exception e)
        {
        }    
    }
    
    
    
    private long nanoBefore = 0;
    private long cpuBefore = 0;
    
    private void operatingSystemMXBean(Application application, long timestamp)
    {
        try
        {
            OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean)ManagementFactory.getOperatingSystemMXBean();
            ApplicationStatus status = application.getDeviceStatus();
            if (status.system == null) status.system = new ApplicationStatusOperatingSystem();
            status.system.timestamp = timestamp;
            status.system.committedVirtualMemorySize = operatingSystemMXBean.getCommittedVirtualMemorySize();
            status.system.freePhysicalMemorySize = operatingSystemMXBean.getFreePhysicalMemorySize();
            status.system.freeSwapSpaceSize = operatingSystemMXBean.getFreeSwapSpaceSize();
            status.system.processCpuLoad = operatingSystemMXBean.getProcessCpuLoad();
            status.system.processCpuTime = operatingSystemMXBean.getProcessCpuTime();
            status.system.systemCpuLoad = operatingSystemMXBean.getSystemCpuLoad();
            status.system.totalPhysicalMemorySize = operatingSystemMXBean.getTotalPhysicalMemorySize();
            status.system.totalSwapSpaceSize = operatingSystemMXBean.getTotalSwapSpaceSize();
            status.system.systemLoadAverage = operatingSystemMXBean.getSystemLoadAverage();
            status.system.availableProcessors = operatingSystemMXBean.getAvailableProcessors();
            status.system.totalPhysicalMemorySize = operatingSystemMXBean.getTotalPhysicalMemorySize();
            status.system.name = operatingSystemMXBean.getName();
            status.system.version = operatingSystemMXBean.getVersion();
            status.system.arch = operatingSystemMXBean.getArch();
            
            if (status.system.systemLoadAverage == -1)
            {
                MBeanServerConnection mbsc = ManagementFactory.getPlatformMBeanServer();
                OperatingSystemMXBean osMBean = ManagementFactory.newPlatformMXBeanProxy(
                mbsc, ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, OperatingSystemMXBean.class);

                if (nanoBefore == 0) 
                {
                    long cpuBefore = osMBean.getProcessCpuTime();
                    long nanoBefore = System.nanoTime();
                }

                long cpuAfter = osMBean.getProcessCpuTime();
                long nanoAfter = System.nanoTime();

                if (nanoAfter > nanoBefore) 
                {
                    status.system.systemLoadAverage = ((cpuAfter-cpuBefore)*100L)/ (nanoAfter-nanoBefore);
                }
                
                nanoBefore = nanoAfter;
                cpuBefore = cpuAfter;
            }
            
        }
        catch (Exception e)
        {
        }    
    }
    
    

    private void updateAlarms(Application application, long timestamp)
    {
        try
        {
            ApplicationInformation information = application.getDeviceInformation();
            ApplicationStatus status = application.getDeviceStatus();
            ApplicationAlarms alarms = application.getDeviceAlarms();
            application.setAlarm("alarm_threads_error", (status.thread.threadCount >=  information.threshold_threads_error),timestamp);
            application.setAlarm("alarm_threads_warning", (status.thread.threadCount >=  information.threshold_threads_warning) && (alarms.alarm_threads_error == 0), timestamp);

            float memoryCommited = (status.memory.heapMemoryUsage_committed + status.memory.nonheapMemoryUsage_committed);
            float memoryused = (status.memory.heapMemoryUsage_used + status.memory.nonheapMemoryUsage_used);
            float memoryLoad = 0.0f;
            if (memoryCommited > 0) memoryLoad = memoryused / memoryCommited;
            application.setAlarm("alarm_memory_error", (memoryLoad >=  information.threshold_memory_error),timestamp);
            application.setAlarm("alarm_memory_warning", (memoryLoad >=  information.threshold_memory_warning) && (alarms.alarm_memory_error == 0), timestamp);
            
            application.setAlarm("alarm_processCpuLoad_error", (status.system.processCpuLoad >= information.threshold_processCpuLoad_error),timestamp);
            application.setAlarm("alarm_processCpuLoad_warning", (status.system.processCpuLoad >= information.threshold_processCpuLoad_warning) && (alarms.alarm_processCpuLoad_error == 0), timestamp);
            application.setAlarm("alarm_systemCpuLoad_error", (status.system.systemCpuLoad >= information.threshold_systemCpuLoad_error),timestamp);
            application.setAlarm("alarm_systemCpuLoad_warning", (status.system.systemCpuLoad >= information.threshold_systemCpuLoad_warning) && (alarms.alarm_systemCpuLoad_error == 0), timestamp);
        }
        catch (Exception e)
        {
        }    
    }
        
   
}