/*
   Copyright (C) 2007 Dirk Huenniger
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  
  package org.indi.server;
  
  import java.io.IOException;
  import java.net.URL;
  import java.nio.channels.ClosedChannelException;
  import java.nio.channels.SelectableChannel;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.HashSet;
  import java.util.PropertyResourceBundle;
  import java.util.Queue;
  import java.util.Set;
  import java.util.concurrent.LinkedBlockingQueue;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.indi.clientmessages.GetProperties;
  import org.indi.objects.TransferType;
  import org.indi.objects.Vector;
  import org.indi.reactor.EventHandler;
  import org.indi.reactor.EventHandlerFactory;
  import org.indi.reactor.Reactor;
  import org.xml.sax.SAXException;
  
  /**
   * An Indiserver to host drivers
   * 
   * @author Dirk Hünniger
   * 
   */
  public class IndiServer {
  
      private final Log log = LogFactory.getLog(IndiServer.class);
      /**
       * A collection of devicedrivers hosted by this server
       */
      public Collection<BasicDevice> drivers;
      /**
       * A collection of clients connected to this server
       */
      public Collection<ClientHandler> clientHandlers;
      /**
       * the reactor used by this server for event dispatching
       */
      public Reactor reactor;
      /**
       * the version of the indisever
       */
      public String version = "1.0";
      /**
       * the set of registered oberservers observing changes of a particular
       * property of a particular driver
       */
      public Set<Observer> observers;
  
      /**
       * class constructor
       * 
       * @throws IOException
       */
      public IndiServer() throws IOException {
  	this.observers = new HashSet<Observer>();
  	this.reactor = new Reactor();
  	Queue<Object> toDriverQueue = new LinkedBlockingQueue<Object>();
  	this.drivers = new ArrayList<BasicDevice>();
  	this.reactor.register(new Dispatcher(toDriverQueue, this));
  	Acceptor a = new Acceptor(this.reactor, new EventHandlerFactory() {
  	    public EventHandler produce(Reactor r, SelectableChannel ch)
  		    throws ClosedChannelException, IOException {
  		try {
  		    return new ClientHandler(r, ch);
  		} catch (ParserConfigurationException e) {
  		    e.printStackTrace();
  		} catch (SAXException e) {
  		    e.printStackTrace();
  		}
  		return null;
  	    }
 	}, 7624, toDriverQueue);
 	this.clientHandlers = a.getClientHandlers();
     }
 
     /**
      * add a new driver to the server
      * 
      * @param driver
      *                the driver to be added
      */
     public void addDriver(BasicDevice driver) {
 	this.drivers.add(driver);
     }
 
     /**
      * add a new observer to the server
      * 
      * @param o
      *                the observer to be added
      */
     public void addObserver(Observer o) {
 	this.observers.add(o);
 	String dev = o.getDevice();
 	GetProperties gp = new GetProperties(this.version, dev);
 	for (Device d : this.drivers) {
 	    String name = d.getName();
 	    if (name == null) {
 		continue;
 	    }
 	    if (name.equals(dev)) {
 		d.onGetProperties(gp);
 	    }
 	}
     }
 
     /**
      * remove an existing obeserver from the server.
      * 
      * @param o
      *                the observer to be removed
      */
     public void removeObserver(Observer o) {
 	this.observers.remove(o);
     }
 
     /**
      * send an indiobject to all interested clients
      * 
      * @param object
      *                the indiobject to be send
      * @param type
      *                the way it should be send
      * @param message
      *                the message to be sent along with the object
      */
     public void sendToClients(org.indi.objects.Object object,
 	    TransferType type, String message) {
 	for (ClientHandler ch : this.clientHandlers) {
 	    ch.send(object, type, message);
 	}
 	if (object instanceof Vector) {
 	    Vector vector = (Vector) object;
 	    vector.setTransferType(type);
 	    for (Observer o : this.observers) {
 		if (vector.getDevice().equals(o.getDevice())) {
 		    if (o.getName().equals(vector.getName())
 			    || vector.getTransferType() == TransferType.Del) {
 			if ((vector.getTransferType() == TransferType.Set)
 				&& o.getState() == ObserverState.State) {
 			    if (o.laststate == vector.getState()) {
 				return;
 			    } else {
 				o.laststate = vector.getState();
 			    }
 			}
 			o.onObserved(vector);
 		    }
 		}
 		;
 
 	    }
 	}
     }
 
     /**
      * 
      * @param args
      */
     public static void main(String[] args) {
 	try {
 	    new IndiServer().startServer(args);
 	} catch (IOException e) {
 	    e.printStackTrace();
 	}
     }
 
     /**
      * 
      * @param args
      */
     private void startServer(String[] args) {
 	try {
 	    ArrayList<String> deveiceToStart = new ArrayList<String>();
 	    nameScanForDevicesToStart(args, deveiceToStart);
 	    classNameScanForDevicesToStart(args, deveiceToStart);
 	    if (!startAtLeastOneDevice(deveiceToStart)) {
 		this.log.error("no drivers successfully started!");
 	    } else {
 		while (true) {
 		    this.reactor.handleEvents(10);
 		}
 	    }
 	} catch (IOException e) {
 	    this.log.error("could not start indi server due to exception", e);
 	}
     }
 
     private void classNameScanForDevicesToStart(String[] args,
 	    ArrayList<String> devicesToStart) {
 	for (String element : args) {
 	    if (element.length() > 0) {
 		try {
 		    Class driverClass = Thread.currentThread()
 			    .getContextClassLoader().loadClass(element);
 		    if (driverClass.isAssignableFrom(BasicDevice.class)) {
 			devicesToStart.add(element);
 		    } else {
 			this.log
 				.error("argument is not a driver or driver class ("
 					+ element + ")");
 		    }
 		} catch (ClassNotFoundException e) {
 		    this.log.error("argument is not a driver class (" + element
 			    + ")", e);
 		}
 	    }
 	}
     }
 
     private void nameScanForDevicesToStart(String[] args,
 	    ArrayList<String> driversToStart) throws IOException {
 	Enumeration<URL> driverresources = Thread.currentThread()
 		.getContextClassLoader().getResources("META-INF/indi");
 	while (driverresources.hasMoreElements()) {
 	    URL url = driverresources.nextElement();
 	    PropertyResourceBundle bundle = new PropertyResourceBundle(url
 		    .openStream());
 	    Enumeration<String> keys = bundle.getKeys();
 	    while (keys.hasMoreElements()) {
 		String driverClassName = keys.nextElement();
 		String driverName = bundle.getString(driverClassName);
 		boolean driverActivated = false;
 		for (int index = 0; index < args.length; index++) {
 		    if (args[index].equals(driverName)) {
 			driversToStart.add(driverClassName);
 			driverActivated = true;
 			args[index] = "";
 		    }
 		}
 		if (!driverActivated) {
 		    this.log.info("detected deacivated driver for "
 			    + driverName + " (" + driverClassName + ")");
 		} else {
 		    this.log.info("detected acivated driver for " + driverName
 			    + " (" + driverClassName + ")");
 		}
 	    }
 	}
     }
 
     /**
      * 
      * @param driversToStart
      * @return
      */
     private boolean startAtLeastOneDevice(ArrayList<String> driversToStart) {
 	boolean atLeastOnDriverStarted = false;
 	for (String driverClassName : driversToStart) {
 	    try {
 		Class driverClass = Thread.currentThread()
 			.getContextClassLoader().loadClass(driverClassName);
 		addDriver((BasicDevice) driverClass.getConstructor(
 			IndiServer.class).newInstance(this));
 		this.log.info("Successfuly started driver class "
 			+ driverClassName);
 		atLeastOnDriverStarted = true;
 	    } catch (Exception e) {
 		this.log.error("could not instanciate Driver: "
 			+ driverClassName + " due to exception", e);
 	    }
 	}
 	return atLeastOnDriverStarted;
     }
 }