/*
 *  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.core.mbean;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InvalidAttributeValueException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.ReflectionException;
import javax.management.RuntimeOperationsException;

import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * Abstract class for Ametys Dynamic MBean.
 */
public abstract class AbstractAmetysDynamicMBean extends AbstractLogEnabled implements DynamicMBean
{
    /** The MBean metadata */
    protected MBeanInfo _mBeanInfo;
    
    /**
     * AbstractAmetysDynamicMBean basic constructor.
     * Generate the MBean info.
     */
    public AbstractAmetysDynamicMBean()
    {
        buildDynamicMBeanInfo();
    }

    @Override
    public Object getAttribute(String attributeName) throws AttributeNotFoundException
    {
     // Check attribute_name to avoid NullPointerException later on
        if (attributeName == null)
        {
            throw new RuntimeOperationsException(
                new IllegalArgumentException("Attribute name cannot be null"), 
                "Cannot invoke a getter of " + this.getClass().getName() + " with null attribute name");
        }

        Object attribute = _getAttribute(attributeName);

        // If attribute_name has not been recognized
        if (attribute == null)
        {
            throw new AttributeNotFoundException("Cannot find " + attributeName + " attribute in " + this.getClass().getName());
        }
        return attribute;
    }

    /** 
     * Get the value of the attribute.
     * This method should assume that attributeName is not null.
     * And return null if the name is not recognized
     * @param attributeName the name of the attribute
     * @return the value of the attribute
     */
    protected abstract Object _getAttribute(String attributeName);

    @Override
    public AttributeList getAttributes(String[] attributeNames)
    {
     // Check attributeNames to avoid NullPointerException later on
        if (attributeNames == null)
        {
            throw new RuntimeOperationsException(
                new IllegalArgumentException(
                    "attributeNames[] cannot be null"),
                "Cannot invoke a getter of " + this.getClass().getName());
        }
        AttributeList resultList = new AttributeList();
        
        // if attributeNames is empty, return an empty result list
        if (attributeNames.length == 0)
        {
            return resultList;
        }
        
        // build the result attribute list
        for (int i = 0; i < attributeNames.length; i++)
        {
            try
            {
                Object value = getAttribute(attributeNames[i]);     
                resultList.add(new Attribute(attributeNames[i], value));
            }
            catch (Exception e)
            {
                getLogger().error("Failed to get attribute {}", attributeNames[i], e);
            }
        }
        return resultList;
    }
    
    @Override
    public Object invoke(String actionName, Object[] params, String[] signature) throws MBeanException, ReflectionException
    {
        // we don't implement any method to invoke so no need
        throw new UnsupportedOperationException("No invoke method defined for this MBean.");
    }

    @Override
    public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException
    {
        // we don't need to set any attribute
        throw new UnsupportedOperationException("Method to set attribute is not defined for this MBean.");
    }

    @Override
    public AttributeList setAttributes(AttributeList attributes)
    {
        // we don't need to set any attribute
        throw new UnsupportedOperationException("Method to set attributes is not defined for this MBean.");
    }
    
    @Override
    public MBeanInfo getMBeanInfo()
    {
        return _mBeanInfo;
    }

    
    private void buildDynamicMBeanInfo()
    {
        _mBeanInfo = new MBeanInfo(getMBeanName(),
                                   getMBeanDescription(),
                                   getMBeanAttributes(),
                                   getMBeanConstructorInfo(),
                                   getMBeanOperationInfo(),
                                   getMBeanNotificationInfo());
    }

    /**
     * Get the human readable name of the MBean.
     * This name will be exposed.
     * @return the name
     */
    protected abstract String getMBeanName();

    /**
     * Get the description of the MBean
     * @return the description
     */
    protected abstract String getMBeanDescription();

    /**
     * Get the definition of the attributes exposed by the MBean.
     * @return the attributes information
     */
    protected abstract MBeanAttributeInfo[] getMBeanAttributes();

    /**
     * Get the definition of the constructors exposed by the MBean.
     * @return the constructors information
     */
    protected MBeanConstructorInfo[] getMBeanConstructorInfo()
    {
        // We usually don't set any constructor
        return new MBeanConstructorInfo[0];
    }

    /**
     * Get the definition of the operation methods exposed by the MBean
     * @return the operations information
     */
    protected MBeanOperationInfo[] getMBeanOperationInfo()
    {
        // We usually don't set any operation
        return new MBeanOperationInfo[0];
    }

    /**
     * Get the definition of the notification exposed by the MBean
     * @return the notification information
     */
    protected MBeanNotificationInfo[] getMBeanNotificationInfo()
    {
        // We usually don't set any notification
        return new MBeanNotificationInfo[0];
    }
    
    /**
     * render a human readable filesize
     * @param size the size in byte
     * @return the human readable string
     */
    protected String _fileSize(long size)
    {
        final long  byteLimit = 1024;
        final long kbLimit = 1048576;
        final long mbLimit = 1073741824;
        String fileSize;
        if (size < byteLimit)
        {
            if (size == 1)
            {
                fileSize = "1 byte";
            }
            else
            {
                fileSize = String.format("%d bytes", size);
            }
        }
        else if (size < kbLimit)
        {
            fileSize = String.format("%.2f KB", ((double) size) / byteLimit);
        }
        else if (size < mbLimit)
        {
            fileSize = String.format("%.2f MB", ((double) size) / kbLimit);
        }
        else
        {
            fileSize = String.format("%.2f GB", ((double) size) / mbLimit);
        }
        
        return fileSize;
    }
}