/*
    * Copyright (C) The Apache Software Foundation. All rights reserved.
    *
    * This software is published under the terms of the Apache Software License
    * version 1.1, a copy of which has been included  with this distribution in
    * the LICENSE.txt file.
    */
   
   package net.sf.jour.log4j;
  
  import java.net.Socket;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.BufferedInputStream;
  
  
  import org.apache.log4j.*;
  import org.apache.log4j.spi.*;
  
  // Contributors:  Moses Hohman <mmhohman@rainbow.uchicago.edu>
  
  /***
     Read {@link LoggingEvent} objects sent from a remote client using
     Sockets (TCP). These logging events are logged according to local
     policy, as if they were generated locally.
  
     <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  Ceki G&uuml;lc&uuml;
  
      @since 0.8.4
  */
  public class ProfilerSocketNode implements Runnable {
  
    Socket socket;
    LoggerRepository hierarchy;
    ObjectInputStream ois;
  
    static Logger logger = Logger.getLogger(ProfilerSocketNode.class);
  
    static int instanceCount = 0;
    int instanceNumber;
    
    public ProfilerSocketNode(Socket socket, LoggerRepository hierarchy) {
      this.socket = socket;
      this.hierarchy = hierarchy;
      this.instanceNumber = ++instanceCount; 
      try {
        ois = new ObjectInputStream(
                           new BufferedInputStream(socket.getInputStream()));
      }
      catch(Exception e) {
        logger.error("Could not open ObjectInputStream to "+socket, e);
      }
    }
  
    //public
    //void finalize() {
    //System.err.println("-------------------------Finalize called");
    // System.err.flush();
    //}
    
    static long eventCnt = 0;
    long thisEventCnt = 0;
    
    public void run() {
      LoggingEvent event;
      ProfilerEvent pEvent;
      ProfilerEventExt pEventExt;
      Logger remoteLogger;
      Logger pLogger;
      long prnCnt = 0;
      try {
          	/*
              while (true) {
                  // read an event from the wire
                  event = (LoggingEvent) ois.readObject();
                  // get a logger from the hierarchy. The name of the logger is taken to be the name
                  // contained in the event.
                  remoteLogger = hierarchy.getLogger(event.getLoggerName());
                  //event.logger = remoteLogger;
                  // apply the logger-level filter
                  if (event.getLevel().isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
                      // finally log the event as if was generated locally
                      remoteLogger.callAppenders(event);
                  }
              }
              */
          	pLogger = hierarchy.getLogger("Profiler");
          	while (true) {
          	    String eventName;
          	    long numEvents = 0;
          	    // read an event from the wire
          	    Object o = ois.readObject();
          	    if (o instanceof ProfilerEvent) {
          	        pEvent = (ProfilerEvent) o;
              		pLogger.debug(pEvent);
              		eventName = "ProfilerEvent";
             		numEvents = 1;
         	    } else if (o instanceof ProfilerEventExt) {
         	        pEventExt = (ProfilerEventExt) o;
             		pLogger.debug(pEventExt);
             		eventName = "ProfilerEventExt";
             		numEvents = 1;
         	    } else if (o instanceof ProfilerEvent[]) {
             	    ProfilerEvent[] events = (ProfilerEvent[]) o;
             	    for(int i = 0; i < events.length; i++) {
             	        pEvent = events[i];
             		    pLogger.debug(pEvent);
             	    }
             	    eventName = "ProfilerEvent[]" + events.length;
             	    numEvents = events.length;
         	    } else if (o instanceof ProfilerEventExt[]) {
             	    ProfilerEventExt[] events = (ProfilerEventExt[]) o;
             	    for(int i = 0; i < events.length; i++) {
             	        pEventExt = events[i];
             		    pLogger.debug(pEventExt);
             	    }
             	    eventName = "ProfilerEventExt[]" + events.length;
             	    numEvents = events.length;
             	} else if (o instanceof LoggingEvent[]) {
             	    LoggingEvent[] events = (LoggingEvent[]) o;
             	    for(int i = 0; i < events.length; i++) {
             	        event = events[i];
             		    remoteLogger = hierarchy.getLogger(event.getLoggerName());
             		    if (event.getLevel().isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
                             // finally log the event as if was generated locally
                             remoteLogger.callAppenders(event);
                         }
             	    }
             	    eventName = "LoggingEvent[]" + events.length;
             	    numEvents = events.length;
         	    } else {
         	        event = (LoggingEvent) o;
         	        //  get a logger from the hierarchy. The name of the logger is taken to be the name
                     // contained in the event.
                     remoteLogger = hierarchy.getLogger(event.getLoggerName());
                     //event.logger = remoteLogger;
                     // apply the logger-level filter
                     if (event.getLevel().isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
                         // finally log the event as if was generated locally
                         remoteLogger.callAppenders(event);
                     }
                     eventName = "LoggingEvent";
                     numEvents = 1;
         	    }
         	    
         	    eventCnt += numEvents;
         	    prnCnt += numEvents;
         	    thisEventCnt += numEvents;
         	    
                 if (prnCnt > 2000) {
                     System.out.println("Cnt=" + eventCnt + " " + this.instanceNumber + " " + eventName);
                     prnCnt = 0;
                 }
         	}
 
         } catch (java.io.EOFException e) {
             logger.info("Caught java.io.EOFException closing conneciton.");
         } catch (java.net.SocketException e) {
             logger.info("Caught java.net.SocketException closing conneciton.");
         } catch (IOException e) {
             logger.info("Caught java.io.IOException: " + e);
             logger.info("Closing connection.");
         } catch (Exception e) {
             logger.error("Unexpected exception. Closing conneciton.", e);
         }
 
         logger.info("Event count:" + thisEventCnt + " of " + eventCnt);
         
     try {
       ois.close();
     } catch(Exception e) {
       logger.info("Could not close connection.", e);
     }
   }
 }