/*
 * jPOS Project [http://jpos.org]
 * Copyright (C) 2000-2026 jPOS Software SRL
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.jpos.q2;

import org.jdom2.Element;
import org.jpos.core.Configurable;
import org.jpos.core.Configuration;
import org.jpos.core.ConfigurationException;
import org.jpos.util.*;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.Iterator;
import java.util.concurrent.ScheduledThreadPoolExecutor;

/**
 * Base class providing lifecycle management and configuration support for Q2 beans (QBean components).
 * @author <a href="mailto:taherkordy@dpi2.dpi.net.ir">Alireza Taherkordi</a>
 * @author <a href="mailto:apr@cs.com.uy">Alejandro P. Revilla</a>
 */
public class QBeanSupport
    implements QBean, QPersist, QBeanSupportMBean, Configurable
{
    Element persist;
    int state;
    Q2 server;
    final Object modifyLock = new Object();
    boolean modified;
    String name;
    String configuredRealm;
    /** Logger associated with this bean. */
    protected Log log;
    /** Configuration applied to this bean by the container. */
    protected Configuration cfg;
    /** Lazily-allocated scheduler shared with subclasses; see {@link #getScheduledThreadPoolExecutor()}. */
    protected ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;

    /** Default constructor. */
    public QBeanSupport () {
        super();
        setLogger (Q2.LOGGER_NAME);
        state = -1;
    }

    @Override
    public void setServer (Q2 server) {
        this.server = server;
    }

    @Override
    public Q2 getServer () {
        return server;
    }
    /**
     * Returns the {@link QFactory} associated with the hosting Q2 server.
     *
     * @return the server's QFactory
     */
    public QFactory getFactory () {
        return getServer().getFactory ();
    }

    @Override
    public void setName (String name) {
        if (this.name == null)
            this.name = name;
        syncLogConfiguration();
        setModified (true);
    }

    @Override
    public void setLogger (String loggerName) {
        log = Log.getLog (loggerName, resolveRealm());
        syncLogConfiguration();
        setModified (true);
    }

    @Override
    public void setRealm (String realm) {
        configuredRealm = realm;
        syncLogConfiguration();
    }

    @Override
    public String getRealm() {
        return log != null ? log.getRealm() : null;
    }

    @Override
    public String getLogger () {
        return log != null ? log.getLogger().getName() : null;
    }

    /**
     * Returns the {@link Log} used by this bean.
     *
     * @return the configured log instance, or {@code null} if logging has not been initialized
     */
    public Log getLog () {
        return log;
    }

    /**
     * Returns the default realm for this bean; subclasses may override.
     * @return default realm string, or null
     */
    protected String defaultRealm() {
        return null;
    }

    @Override
    public String getName () {
        return name;
    }

    @Override
    public void init () {
        if (state == -1) {
            setModified (false);
            try {
                initService();
                state = QBean.STOPPED;
            } catch (Throwable t) {
                log.warn ("init", t);
            }
        }
    }

    @Override
    public synchronized void start() {
        if (state != QBean.DESTROYED &&
            state != QBean.STOPPED   &&
            state != QBean.FAILED)
           return;

        this.state = QBean.STARTING;

        try {
           startService();
        } catch (Throwable t) {
           state = QBean.FAILED;
           log.warn ("start", t);
           return;
        }
        state = QBean.STARTED;
    }

    @Override
    public synchronized void stop () {
        if (state != QBean.STARTED)
           return;
        state = QBean.STOPPING;
        try {
           stopService();
        } catch (Throwable t) {
           state = QBean.FAILED;
           log.warn ("stop", t);
           return;
        }
        state = QBean.STOPPED;
    }

    @Override
    public void destroy () {
        if (state == QBean.DESTROYED)
           return;
        if (state != QBean.STOPPED)
           stop();

        if (scheduledThreadPoolExecutor != null) {
            scheduledThreadPoolExecutor.shutdown();
            scheduledThreadPoolExecutor = null;
        }
        try {
           destroyService();
        }
        catch (Throwable t) {
           log.warn ("destroy", t);
        }
        state = QBean.DESTROYED;
    }

    @Override
    public int getState () {
        return state;
    }

    @Override
    public URL[] getLoaderURLS() {
        return server.getLoader().getURLs();
    }

    @Override
    public QClassLoader getLoader() {
        return server.getLoader();
    }

    @Override
    public String getStateAsString () {
        return state >= 0 ? stateString[state] : "Unknown";
    }

    /**
     * Sets the lifecycle state of this bean.
     *
     * @param state one of the QBean state constants
     */
    public void setState (int state) {
        this.state = state;
    }

    @Override
    public void setPersist (Element persist) {
        this.persist = persist ;
    }

    @Override
    public Element getPersist () {
        setModified (false);
        return persist;
    }

    /**
     * Marks this bean's persistent state as modified or in sync.
     *
     * @param modified {@code true} if the bean has unsaved changes
     */
    public void setModified (boolean modified) {
        synchronized (this.modifyLock) {
            this.modified = modified;
        }
    }

    @Override
    public boolean isModified () {
        synchronized (this.modifyLock) {
            return modified;
        }
    }

    /**
     * Indicates whether this bean is currently starting or running.
     *
     * @return {@code true} if the state is {@link QBean#STARTING} or {@link QBean#STARTED}
     */
    public boolean running () {
        return state == QBean.STARTING || state == QBean.STARTED;
    }

    @Override
    public void setConfiguration (Configuration cfg)
      throws ConfigurationException
    {
        this.cfg = cfg;
    }
    /**
     * Returns the configuration applied to this bean.
     *
     * @return the bean's {@link Configuration}, or {@code null} if not yet configured
     */
    public Configuration getConfiguration () {
        return cfg;
    }

    private String resolveRealm() {
        if (configuredRealm != null)
            return configuredRealm;
        String defaultRealm = defaultRealm();
        if (defaultRealm != null)
            return defaultRealm;
        return name != null ? name : getClass().getName();
    }

    private void syncLogConfiguration() {
        if (log == null)
            return;
        log.setRealm(resolveRealm());
        log.removeDefaultTag("component");
        if (configuredRealm == null && defaultRealm() != null && name != null)
            log.setDefaultTag("component", name);
    }

    /**
     * Returns a textual dump of this bean's state.
     *
     * <p>If the bean implements {@link Loggeable}, its {@code dump} output is returned;
     * otherwise this delegates to {@link #toString()}.
     *
     * @return a string representation suitable for diagnostics
     */
    public String getDump () {
        if (this instanceof Loggeable) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            PrintStream p = new PrintStream(baos);
            ((Loggeable)this).dump(p, "");
            return baos.toString();
        }
        return toString();
    }
    /**
     * Called during the init lifecycle phase; subclasses may override.
     * @throws Exception on error
     */
    protected void initService()    throws Exception {}
    /**
     * Called during the start lifecycle phase; subclasses may override.
     * @throws Exception on error
     */
    protected void startService()   throws Exception {}
    /**
     * Called during the stop lifecycle phase; subclasses may override.
     * @throws Exception on error
     */
    protected void stopService()    throws Exception {}
    /**
     * Called during the destroy lifecycle phase; subclasses may override.
     * @throws Exception on error
     */
    protected void destroyService() throws Exception {}

    /**
     * Lazily creates and returns a {@link ScheduledThreadPoolExecutor} for use by subclasses.
     *
     * @return shared scheduled executor for this bean
     */
    protected synchronized ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() {
        if (scheduledThreadPoolExecutor == null)
            scheduledThreadPoolExecutor = ConcurrentUtil.newScheduledThreadPoolExecutor();
        return scheduledThreadPoolExecutor;
    }

    /**
     * Builds a JDOM {@link Element} reflecting the bean's persistent attributes,
     * driven by the JavaBean introspection of {@code mbeanClass}.
     *
     * @param name the root element name
     * @param mbeanClass the MBean interface whose properties drive serialization
     * @return populated element ready for persistence
     */
    protected Element createElement (String name, Class mbeanClass) {
        Element e = new Element (name);
        Element classPath = persist != null ?
            persist.getChild ("classpath") : null;
        if (classPath != null)
            e.addContent (classPath);
        e.setAttribute ("class", getClass().getName());
        if (!e.getName().equals (getName ()))
            e.setAttribute ("name", getName());
        String loggerName = getLogger();
        if (loggerName != null)
            e.setAttribute ("logger", loggerName);

        try {
            BeanInfo info = Introspector.getBeanInfo (mbeanClass);
            PropertyDescriptor[] desc = info.getPropertyDescriptors();
            for (PropertyDescriptor aDesc : desc) {
                if (aDesc.getWriteMethod() != null) {
                    Method read = aDesc.getReadMethod();
                    Object obj = read.invoke(this);
                    String type = read.getReturnType().getName();
                    if ("java.lang.String".equals(type))
                        type = null;

                    addAttr(e, aDesc.getName(), obj, type);
                }
            }
        } catch (Exception ex) {
            log.warn ("get-persist", ex);
        }
        return e;
    }
    /**
     * Appends an {@code <attr>} child element with name/type/value to {@code e}.
     *
     * @param e parent element
     * @param name attribute name
     * @param obj value (rendered via {@code toString()}; {@code null} becomes the literal "null")
     * @param type optional Java type hint, or {@code null} to omit
     */
    protected void addAttr (Element e, String name, Object obj, String type) {
        String value = obj == null ? "null" : obj.toString();
        Element attr = new Element ("attr");
        attr.setAttribute ("name", name);
        if (type != null)
            attr.setAttribute ("type", type);
        attr.setText (value);
        e.addContent (attr);
    }
    /**
     * Iterates over top-level {@code <attr>} children of the persisted element.
     *
     * @return iterator over the persisted attribute elements
     */
    protected Iterator getAttrs () {
        return getPersist().getChildren ("attr").iterator();
    }
    /**
     * Iterates over {@code <attr>} children nested under the given parent element name.
     *
     * @param parent name of the parent element under {@link #getPersist()}
     * @return iterator over the nested attribute elements
     */
    protected Iterator getAttrs (String parent) {
        return getPersist().getChild(parent).
            getChildren("attr").iterator();
    }
    /**
     * Updates the value of the named attribute within an iterator of {@code <attr>} elements.
     *
     * @param attrs iterator over candidate attribute elements
     * @param name name of the attribute to update
     * @param obj new value (rendered via {@code toString()}; {@code null} becomes "null")
     */
    protected void setAttr (Iterator attrs, String name, Object obj) {
        String value = obj == null ? "null" : obj.toString ();
        while (attrs.hasNext ()) {
            Element e = (Element) attrs.next ();
            if (name.equals (e.getAttributeValue ("name")))  {
                e.setText(value);
                break;
            }
        }
    }
    /**
     * Iterates over {@code <property>} children nested under the given parent element name.
     *
     * @param parent name of the parent element under {@link #getPersist()}
     * @return iterator over the nested property elements
     */
    protected Iterator getProperties (String parent) {
        return getPersist().getChild (parent).
               getChildren ("property").iterator();
    }
    /**
     * Updates the value attribute of the named property within an iterator of {@code <property>} elements.
     *
     * @param props iterator over candidate property elements
     * @param name name of the property to update
     * @param value new value to assign
     */
    protected void setProperty (Iterator props, String name, String value) {
        while (props.hasNext()) {
            Element e = (Element) props.next();
            if (name.equals (e.getAttributeValue ("name"))) {
                e.setAttribute ("value", value);
                break;
            }
        }
    }
    /**
     * Returns the value of the named property from an iterator of {@code <property>} elements.
     *
     * @param props iterator over candidate property elements
     * @param name name of the property to look up
     * @return the property's value, or {@code null} if not found
     */
    protected String getProperty (Iterator props, String name) {
        while (props.hasNext()) {
            Element e = (Element) props.next();
            if (name.equals (e.getAttributeValue ("name"))) {
                return e.getAttributeValue ("value");
            }
        }
        return null;
    }
    /**
     * Closes a sequence of {@link Closeable} resources, logging any failures as a warning.
     *
     * @param closeables resources to close (each is closed independently of the others)
     */
    protected void close (Closeable... closeables) {
        LogEvent evt = null;
        for (Closeable c : closeables) {
            try {
                c.close();
            } catch (Exception e) {
                if (evt == null)
                    evt = getLog().createWarn();
                evt.addMessage(e);
            }
        }
        if (evt != null)
            Logger.log(evt);
    }
}