/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.log4j.net;

import org.apache.log4j.Logger;
import org.apache.log4j.helpers.Constants;
import org.apache.log4j.plugins.Receiver;
import org.apache.log4j.spi.ComponentBase;
import org.apache.log4j.spi.Decoder;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.spi.LoggingEvent;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.util.List;


/**
 * Read {@link LoggingEvent} objects sent from a remote client using XML over
 * Sockets (TCP). These logging events are logged according to local
 * policy, as if they were generated locally.
 * <p>
 * <p>For example, the socket node might decide to log events to a
 * local file and also resent them to a second socket node.
 *
 * @author Scott Deboy &lt;sdeboy@apache.org&gt;;
 * @since 0.8.4
 */
public class XMLSocketNode extends ComponentBase implements Runnable {
    Socket socket;
    Receiver receiver;
    Decoder decoder;
    SocketNodeEventListener listener;

    /**
     * Constructor for socket and logger repository.
     */
    public XMLSocketNode(
        String decoder, Socket socket, LoggerRepository hierarchy) {
        this.repository = hierarchy;
        try {
            Class c = Class.forName(decoder);
            Object o = c.newInstance();

            if (o instanceof Decoder) {
                this.decoder = (Decoder) o;
            }
        } catch (ClassNotFoundException cnfe) {
            getLogger().warn("Unable to find decoder", cnfe);
        } catch (IllegalAccessException | InstantiationException iae) {
            getLogger().warn("Unable to construct decoder", iae);
        }

        this.socket = socket;
    }

    /**
     * Constructor for socket and reciever.
     */
    public XMLSocketNode(String decoder, Socket socket, Receiver receiver) {
        try {
            Class c = Class.forName(decoder);
            Object o = c.newInstance();

            if (o instanceof Decoder) {
                this.decoder = (Decoder) o;
            }
        } catch (ClassNotFoundException cnfe) {
            getLogger().warn("Unable to find decoder", cnfe);
        } catch (IllegalAccessException | InstantiationException iae) {
            getLogger().warn("Unable to construct decoder", iae);
        }

        this.socket = socket;
        this.receiver = receiver;
    }

    /**
     * Set the event listener on this node.
     */
    public void setListener(SocketNodeEventListener _listener) {
        listener = _listener;
    }

    public void run() {
        Logger remoteLogger;
        Exception listenerException = null;
        InputStream is;

        if ((this.receiver == null) || (this.decoder == null)) {
            listenerException =
                new Exception(
                    "No receiver or decoder provided.  Cannot process xml socket events");
            getLogger().error(
                "Exception constructing XML Socket Receiver", listenerException);
        }

        try {
            is = socket.getInputStream();
        } catch (Exception e) {
            is = null;
            listenerException = e;
            getLogger().error("Exception opening InputStream to " + socket, e);
        }

        if (is != null) {
            String hostName = socket.getInetAddress().getHostName();
            String remoteInfo = hostName + ":" + socket.getPort();

            try {
                //read data from the socket
                //it's up to the individual decoder to handle incomplete event data
                while (true) {
                    byte[] b = new byte[1024];
                    int length = is.read(b);
                    if (length == -1) {
                        getLogger().info(
                            "no bytes read from stream - closing connection.");
                        break;
                    }
                    List<LoggingEvent> v = decoder.decodeEvents(new String(b, 0, length));

                    if (v != null) {

                        for (Object aV : v) {
                            LoggingEvent e = (LoggingEvent) aV;
                            e.setProperty(Constants.HOSTNAME_KEY, hostName);

                            // store the known remote info in an event property
                            e.setProperty("log4j.remoteSourceInfo", remoteInfo);

                            // if configured with a receiver, tell it to post the event
                            if (receiver != null) {
                                receiver.doPost(e);

                                // else post it via the hierarchy
                            } else {
                                // get a logger from the hierarchy. The name of the logger
                                // is taken to be the name contained in the event.
                                remoteLogger = repository.getLogger(e.getLoggerName());

                                //event.logger = remoteLogger;
                                // apply the logger-level filter
                                if (
                                    e.getLevel().isGreaterOrEqual(
                                        remoteLogger.getEffectiveLevel())) {
                                    // finally log the event as if was generated locally
                                    remoteLogger.callAppenders(e);
                                }
                            }
                        }
                    }
                }
            } catch (java.io.EOFException e) {
                getLogger().info("Caught java.io.EOFException closing connection.");
                listenerException = e;
            } catch (java.net.SocketException e) {
                getLogger().info(
                    "Caught java.net.SocketException closing connection.");
                listenerException = e;
            } catch (IOException e) {
                getLogger().info("Caught java.io.IOException: " + e);
                getLogger().info("Closing connection.");
                listenerException = e;
            } catch (Exception e) {
                getLogger().error("Unexpected exception. Closing connection.", e);
                listenerException = e;
            }
        }

        // close the socket
        try {
            if (is != null) {
                is.close();
            }
        } catch (Exception e) {
            //logger.info("Could not close connection.", e);
        }

        // send event to listener, if configured
        if (listener != null) {
            listener.socketClosedEvent(listenerException);
        }
    }
}