/*
    * Jour - java profiler and monitoring library
    *
    * Copyright (C) 2004 Jour team
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Library General Public
    * License as published by the Free Software Foundation; either
    * version 2 of the License, or (at your option) any later version.
   *
   * This library 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
   * Library General Public License for more details.
   *
   * You should have received a copy of the GNU Library General Public
   * License along with this library; if not, write to the
   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   * Boston, MA  02111-1307, USA.
   */
  package net.sf.jour.rt.agent;
  
  import java.io.File;
  import java.io.*;
  import java.io.IOException;
  import java.io.EOFException;
  import java.util.*;
  
  import java.io.FileInputStream;
  import java.io.ObjectInputStream;
  
  
  import org.apache.log4j.Logger;
  
  import net.sf.jour.util.queue.Queue;
  import net.sf.jour.util.FileUtil;
  import net.sf.jour.rt.RtProperties;
  
  /***
   * TODO Add docs
   * Created on 05.12.2004
   *
   * Contributing Author(s):
   *
   *   Misha Lifschitz <mishalifschitz at users.sourceforge.net> (Inital implementation)
   *   Vlad Skarzhevskyy <vlads at users.sourceforge.net> (Inital implementation)
   *
   * @author vlads
   * @version $Revision: 1.9 $ ($Author: vlads $) $Date: 2004/12/16 00:08:42 $
   */
  public class BulkEventFileReader implements Runnable {
  
  	protected final Logger log = Logger.getLogger(BulkEventFileReader.class);
  
  	private static EventQueueLogger eventLogger = (EventQueueLogger) EventQueueLogger.getInstance();
  
  	private static Hashtable loaded;
  	private static boolean resetFlag;
  	
  	/* Reading and sorting file list may be too expensive on Windows */
  	private File[] cashfileList;
  	private String cashDirectory;
  
  	private BulkEventFileReader() {
  		log.debug("new BulkEventFileReader()");
  	}
  
  	public static void start() {
  		new Thread(new BulkEventFileReader()).start();
  	}
  
  	public static void reset() {
  		loaded = null;
  		resetFlag = true;
  	}
  
  	private synchronized Hashtable getTable() {
  		if (loaded == null) {
  			loaded = new Hashtable();
  		}
  		return loaded;
  	}
  
      private Queue process(File file) {
          try {
              getTable().put(file.getCanonicalPath(), new Boolean(true));
          } catch (IOException e) {
              log.error("file error " + file.getName(), e);
              return null;
          }
  
  		try {
  			log.debug("Reading file:"  + file.getName());
              FileInputStream fis  = new FileInputStream(file);
  			ObjectInputStream ois = new ObjectInputStream(fis);
  
  			Queue eventQueue = new Queue();
  
              int cnt = 0;
             ThreadNumber tn = null;
             SystemInfoEvent si = null;
             while (true) {
                 Object q;
                 try {
                     q = ois.readObject();
                 } catch (EOFException e1) {
                     break;
                 }
                 if (q instanceof ThreadNumber) {
                     tn = (ThreadNumber)q;
                 }else if (q instanceof SystemInfoEvent) {
                     si = (SystemInfoEvent)q;
                 } else if (q instanceof Event) {
                     eventQueue.enqueue(q);
                 } else if (q instanceof Queue) {
                 	cnt ++;
 					log.debug("Reading Queue" + cnt);
                     eventQueue.enqueueAll((Queue) q);
                 } else {
                 	log.warn("Unknow object:" + q.getClass().getName());
                 	break;
                 }
             }
 
 			fis.close();
 
 			log.debug("Loaded queue:" + eventQueue.size());
 
 			for (Iterator i = eventQueue.iterator(); i.hasNext(); ) {
 			    Object obj = i.next();
 			    if (obj instanceof ThreadNumber) {
 			        tn = (ThreadNumber)obj;
 			    } else if (obj instanceof JVMInfoEvent) {
 			        ((JVMInfoEvent)obj).setSystemInfo(si);
 			    } else if (obj instanceof SystemInfoEvent) {
 	                si = (SystemInfoEvent)obj;
 	            } else if (obj instanceof ProfilerEvent) {
 	                ProfilerEvent e = (ProfilerEvent)obj;
 	    			String threadName = ThreadNumber.getUniqueThreadName(tn, si);
 			    	e.setThreadName(threadName);
 	            }
 			}
 
 			// reset been called
 			if (loaded == null) {
 				return null;
 			}
 			return eventQueue;
 
         } catch (Exception e) {
 			log.error("file read error " + file.getName(), e);
 			return null;
         }
     }
 
 	private boolean isLoaded(File file) {
 		try {
             return getTable().containsKey(file.getCanonicalPath());
         } catch (IOException e) {
             log.error("file error " + file.getName(), e);
             return true;
         }
 	}
 	
 	public class BinFilenameFilter implements FilenameFilter {
 	    public boolean accept(File dir, String name)  {
 	        if ((name.endsWith(".bin")) ||
 					(name.endsWith(".wrk"))) {
 				return true;
 			} else {
 			    return false;
 			}
 	    }
 	}
 	
 	private File[] append(File[] a1, File[] a2) {
 	    if (a2.length == 0) {
 	        return a1;
 	    }
 	    if (a1.length == 0) {
 	        return a2;
 	    }
 	    File[] flist = new File[a1.length + a2.length];
 	    int i = 0;
 	    for (int k =0 ; k < a1.length; i++, k ++) {
 	        flist[i] = a1[k];
 	    }
 	    for (int k = 0 ; k < a2.length; i++, k ++) {
 	        flist[i] = a2[k];
 	    }
 	    return flist;
 	}
 	
 	private File[] getSubFolderFiles(File dir) {
 	    
 	    File[] flist = new File[0];
 	    File[] dirList = dir.listFiles();
 		
 	    for (int i = 0; i < dirList.length; i++) {
 			File subDir = dirList[i];
 			if (!subDir.isDirectory()) {
 			    continue;
 			}
 			File[] subDirFilelist = subDir.listFiles(new BinFilenameFilter());
 			flist = append(flist, subDirFilelist);
 		}
 		return flist;
 	}
 	
 	private Queue read() {
 		File dir = RtProperties.getInstance().getFolder("BulkEventFileReader.folder", false);
 		log.debug("Reading folder:"  + dir);
 		if (dir == null) {
 			return null;
 		}
 		File[] flist;
 		
 		if ((cashDirectory != null) && (cashfileList != null) && (cashDirectory.equals(dir.getAbsolutePath()))) {
             flist = cashfileList;
         } else {
             cashDirectory = dir.getAbsolutePath();
             flist = dir.listFiles(new BinFilenameFilter());
             if (flist.length == 0) {
                 flist = getSubFolderFiles(dir);
             }
             flist = FileUtil.sortFileListByDate(flist);
             cashfileList = flist;
         }
 
 		for (int i = 0; i < flist.length; i++) {
 			File f1 = flist[i];
 			if ((f1.getName().endsWith(".bin")) ||
 				(f1.getName().endsWith(".wrk"))) {
 				if (isLoaded(f1)) {
 					continue;
 				}
 				return process(f1);
 			}
 		}
 
 		return null;
 	}
 
 	public void run() {
 	    long idleCount = 0;
 		while (true) {
 			try {
 				Queue eventQueue = read();
 				if (eventQueue != null) {
 					eventLogger.enqueueAll(eventQueue);
 					idleCount = 0;
 				} else {
 				    idleCount ++;
 				    if (idleCount > 10) {
 				        Thread.sleep(5000); // 5 sec
 				        if (resetFlag) {
 				            cashfileList = null;
 				            resetFlag = false; 
 				        } else if ((idleCount % 12) == 0){
 				            // Reset list every min.
 				            cashfileList = null;
 				        }
 				    } else {
 				        Thread.sleep(200);
 				    }
 				}
 			} catch (Exception e) {
 				log.error("Error", e);
 			}
 		}
 	}
 
 }