/**
* $RCSfile$
* $Revision$
* $Date$
*
* Copyright (C) 2002-2004 Jive Software. All rights reserved.
* ====================================================================
* The Jive Software License (based on Apache Software License, Version 1.1)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in
*    the documentation and/or other materials provided with the
*    distribution.
*
* 3. The end-user documentation included with the redistribution,
*    if any, must include the following acknowledgment:
*       "This product includes software developed by
*        Jive Software (http://www.jivesoftware.com)."
*    Alternately, this acknowledgment may appear in the software itself,
*    if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Smack" and "Jive Software" must not be used to
*    endorse or promote products derived from this software without
*    prior written permission. For written permission, please
*    contact webmaster@jivesoftware.com.
*
* 5. Products derived from this software may not be called "Smack",
*    nor may "Smack" appear in their name, without prior written
*    permission of Jive Software.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.  IN NO EVENT SHALL JIVE SOFTWARE OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*/

package org.jivesoftware.smackx.workgroup.packet;

import java.util.*;
import java.beans.PropertyDescriptor;

import org.jivesoftware.smack.packet.*;
import org.jivesoftware.smack.provider.PacketExtensionProvider;
import org.jivesoftware.smack.provider.ProviderManager;
import org.xmlpull.v1.XmlPullParser;
import org.jivesoftware.smackx.workgroup.agent.Agent;

/**
 * An immutable container around the basic data known about a given agent, as well as a
 *  PacketExtension implementor which knows how to write the agent-status packet extension.
 *  The packet extension implementation doesn't transmit its presence information as, due to
 *  the protocol design, that is to be done by the presence packet which houses this extension.
 *  Similarly, the agent-status packet extension transmits nothing about the agent id, nor
 *  the metadata.<br>
 *
 * PENDING: feels hacky to carry around the presence packet, but it's an adequate container
 *  for the time being.<br>
 *
 * @author loki der quaeler
 */
public class AgentStatus implements PacketExtension {

     /**
     * Element name of the packet extension.
     */
    public static final String ELEMENT_NAME = "agent-status";

    /**
     * Namespace of the packet extension.
     */
    public static final String NAMESPACE = "xmpp:workgroup";

    private Set agents;

    AgentStatus() {
        agents = new HashSet();
    }

    void addAgent(Agent agent) {
        synchronized (agents) {
            agents.add(agent);
        }
    }

    public int getAgentCount() {
        synchronized (agents) {
            return agents.size();
        }
    }

    public Set getAgents() {
        synchronized (agents) {
            return Collections.unmodifiableSet(agents);
        }
    }

    public String getElementName () {
        return ELEMENT_NAME;
    }

    public String getNamespace () {
        return NAMESPACE;
    }

    public String toXML () {
        StringBuffer buf = new StringBuffer();

        buf.append("<").append(ELEMENT_NAME).append(" xmlns=\"").append(NAMESPACE).append("\">");

        synchronized (agents) {
            for (Iterator i=agents.iterator(); i.hasNext(); ) {
                Agent agent = (Agent)i.next();
                buf.append("<agent jid=\"").append(agent.getUser()).append("\">");

                if (agent.getCurrentChats() != -1) {
                    buf.append("<current-chats>");
                    buf.append(agent.getCurrentChats());
                    buf.append("</current-chats>");
                }

                if (agent.getMaxChats() != -1) {
                    buf.append("<max-chats>").append(agent.getMaxChats()).append("</max-chats>");
                }

                if (agent.getPresence() != null) {
                    buf.append(agent.getPresence().toXML());
                    // TODO: ensure that presence.toXML method is ok, then delete code below.
                    /*Presence presence = agent.getPresence();
                    int priority = presence.getPriority();
                    Presence.Mode mode = presence.getMode();
                    String status = presence.getStatus();

                    buf.append("<presence>");
                    if (status != null) {
                        buf.append("<status>").append(status).append("</status>");
                    }
                    if (priority != -1) {
                        buf.append("<priority>").append(priority).append("</priority>");
                    }
                    if (mode != null && mode != Presence.Mode.AVAILABLE) {
                        buf.append("<show>").append(mode).append("</show>");
                    }
                    buf.append("</presence>");*/
                }

                buf.append("</agent>");
            }
        }

        buf.append("</").append(this.getElementName()).append("> ");

        return buf.toString();
    }

    /**
     * Packet extension provider for AgentStatus packets.
     */
    public static class Provider implements PacketExtensionProvider {

        public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
            AgentStatus agentStatus = new AgentStatus();

            int eventType = parser.getEventType();
            if (eventType != XmlPullParser.START_TAG) {
                throw new IllegalStateException("Parser not in proper position, or bad XML.");
            }

            eventType = parser.next();

            while ((eventType == XmlPullParser.START_TAG)
                            && ("agent".equals(parser.getName()))) {
                String jid = null;
                int currentChats = -1;
                int maxChats = -1;
                Presence presence = null;

                jid = parser.getAttributeValue("", "jid");
                if (jid == null) {
                    // throw exception
                }

                eventType = parser.next();
                String elementName = parser.getName();
                while ((eventType != XmlPullParser.END_TAG) || (!"agent".equals(elementName))) {
                    if ("current-chats".equals(elementName)) {
                        currentChats = Integer.parseInt(parser.nextText());
                        parser.next();
                    }
                    else if ("max-chats".equals(elementName)) {
                        maxChats = Integer.parseInt(parser.nextText());
                        parser.next();
                    }
                    else if ("presence".equals(elementName)) {
                        presence = parsePresence(parser);
                        parser.next();
                    }

                    eventType = parser.getEventType();
                    elementName = parser.getName();

                    if (eventType != XmlPullParser.END_TAG) {
                        // throw exception
                    }
                }

                Agent agent = new Agent(jid, currentChats, maxChats, presence);
                agentStatus.addAgent(agent);

                eventType = parser.next();
            }

            if (eventType != XmlPullParser.END_TAG) {
                // throw exception -- PENDING logic verify: useless case?
            }

            return agentStatus;
        }


        // Note: all methods below are copied directly from the Smack PacketReader class
        // and represent all methods that are needed for presence packet parsing.
        // Unfortunately, there is no elegant way to pass of presence packet parsing to
        // Smack core when the presence packet context is a non-standard one such as in
        // the agent-status protocol. Future Smack changes may change this situation,
        // which would allow us to delete the code copy.

        /**
         * Parses a presence packet.
         *
         * @param parser the XML parser, positioned at the start of a presence packet.
         * @return an Presence object.
         * @throws Exception if an exception occurs while parsing the packet.
         */
        private Presence parsePresence(XmlPullParser parser) throws Exception {
            Presence.Type type = Presence.Type.fromString(parser.getAttributeValue("", "type"));

            Presence presence = new Presence(type);
            presence.setTo(parser.getAttributeValue("", "to"));
            presence.setFrom(parser.getAttributeValue("", "from"));
            presence.setPacketID(parser.getAttributeValue("", "id"));

            // Parse sub-elements
            boolean done = false;
            while (!done) {
                int eventType = parser.next();
                if (eventType == XmlPullParser.START_TAG) {
                    String elementName = parser.getName();
                    String namespace = parser.getNamespace();
                    if (elementName.equals("status")) {
                        presence.setStatus(parser.nextText());
                    }
                    else if (elementName.equals("priority")) {
                        try {
                            int priority = Integer.parseInt(parser.nextText());
                            presence.setPriority(priority);
                        }
                        catch (NumberFormatException nfe) { }
                    }
                    else if (elementName.equals("show")) {
                        presence.setMode(Presence.Mode.fromString(parser.nextText()));
                    }
                    else if (elementName.equals("error")) {
                        presence.setError(parseError(parser));
                    }
                    // Otherwise, it must be a packet extension.
                    else {
                        presence.addExtension(parsePacketExtension(elementName, namespace, parser));
                    }
                }
                else if (eventType == XmlPullParser.END_TAG) {
                    if (parser.getName().equals("presence")) {
                        done = true;
                    }
                }
            }
            return presence;
        }

        /**
         * Parses a packet extension sub-packet.
         *
         * @param elementName the XML element name of the packet extension.
         * @param namespace the XML namespace of the packet extension.
         * @param parser the XML parser, positioned at the starting element of the extension.
         * @return a PacketExtension.
         * @throws Exception if a parsing error occurs.
         */
        private PacketExtension parsePacketExtension(String elementName, String namespace,
                XmlPullParser parser) throws Exception
        {
            // See if a provider is registered to handle the extension.
            Object provider = ProviderManager.getExtensionProvider(elementName, namespace);
            if (provider != null) {
                if (provider instanceof PacketExtensionProvider) {
                    return ((PacketExtensionProvider)provider).parseExtension(parser);
                }
                else if (provider instanceof Class) {
                    return (PacketExtension)parseWithIntrospection(
                            elementName, (Class)provider, parser);
                }
            }
            // No providers registered, so use a default extension.
            DefaultPacketExtension extension = new DefaultPacketExtension(elementName, namespace);
            boolean done = false;
            while (!done) {
                int eventType = parser.next();
                if (eventType == XmlPullParser.START_TAG) {
                    String name = parser.getName();
                    // If an empty element, set the value with the empty string.
                    if (parser.isEmptyElementTag()) {
                        extension.setValue(name,"");
                    }
                    // Otherwise, get the the element text.
                    else {
                        eventType = parser.next();
                        if (eventType == XmlPullParser.TEXT) {
                            String value = parser.getText();
                            extension.setValue(name, value);
                        }
                    }
                }
                else if (eventType == XmlPullParser.END_TAG) {
                    if (parser.getName().equals(elementName)) {
                        done = true;
                    }
                }
            }
            return extension;
        }

        private Object parseWithIntrospection(String elementName,
                Class objectClass, XmlPullParser parser) throws Exception
        {
            boolean done = false;
            Object object = objectClass.newInstance();
            while (!done) {
                int eventType = parser.next();
                if (eventType == XmlPullParser.START_TAG) {
                    String name = parser.getName();
                    String stringValue = parser.nextText();
                    PropertyDescriptor descriptor = new PropertyDescriptor(name, objectClass);
                    // Load the class type of the property.
                    Class propertyType = descriptor.getPropertyType();
                    // Get the value of the property by converting it from a
                    // String to the correct object type.
                    Object value = decode(propertyType, stringValue);
                    // Set the value of the bean.
                    descriptor.getWriteMethod().invoke(object, new Object[] { value });
                }
                else if (eventType == XmlPullParser.END_TAG) {
                    if (parser.getName().equals(elementName)) {
                        done = true;
                    }
                }
            }
            return object;
        }

        /**
         * Decodes a String into an object of the specified type. If the object
         * type is not supported, null will be returned.
         *
         * @param type the type of the property.
         * @param value the encode String value to decode.
         * @return the String value decoded into the specified type.
         */
        private static Object decode(Class type, String value) throws Exception {
            if (type.getName().equals("java.lang.String")) {
                return value;
            }
            if (type.getName().equals("boolean")) {
                return Boolean.valueOf(value);
            }
            if (type.getName().equals("int")) {
                return Integer.valueOf(value);
            }
            if (type.getName().equals("long")) {
                return Long.valueOf(value);
            }
            if (type.getName().equals("float")) {
                return Float.valueOf(value);
            }
            if (type.getName().equals("double")) {
                return Double.valueOf(value);
            }
            if (type.getName().equals("java.lang.Class")) {
                return Class.forName(value);
            }
            return null;
        }

        /**
         * Parses error sub-packets.
         *
         * @param parser the XML parser.
         * @return an error sub-packet.
         * @throws Exception if an exception occurs while parsing the packet.
         */
        private XMPPError parseError(XmlPullParser parser) throws Exception {
            String errorCode = null;
            for (int i=0; i<parser.getAttributeCount(); i++) {
                if (parser.getAttributeName(i).equals("code")) {
                    errorCode = parser.getAttributeValue("", "code");
                }
            }
            String message = parser.nextText();
            while (true) {
                if (parser.getEventType() == XmlPullParser.END_TAG && parser.getName().equals("error")) {
                    break;
                }
            }
            return new XMPPError(Integer.parseInt(errorCode), message);
        }
    }
}