package de.desy.acop.video.displayer;
   
   import java.util.logging.Handler;
   import java.util.logging.Level;
   import java.util.logging.LogRecord;
   import java.util.logging.Logger;
   import java.util.logging.StreamHandler;
   
   import de.desy.acop.transport.ConnectionFailed;
  import de.desy.acop.transport.ConnectionParameters;
  import de.desy.tine.client.TLink;
  import de.desy.tine.client.TLinkCallback;
  import de.desy.tine.dataUtils.TDataType;
  import de.desy.tine.definitions.TAccess;
  import de.desy.tine.definitions.TFormat;
  import de.desy.tine.definitions.TMode;
  import de.desy.tine.queryUtils.TPropertyQuery;
  import de.desy.tine.queryUtils.TQuery;
  import de.desy.tine.types.IMAGE;
  
  /**
   * <code>TineHandler</code> encapsulates and divides reception of VSv3 and VSv2
   * image streams from displaying class ImageDisplayerTest. It implements probing
   * of sources and reception, prearrangement and forwarding of video image blobs
   * from TINE to displaying part.
   * 
   * @author <a href="mailto:stefan.weisse@desy.de">Stefan Weisse</a>
   * @author <a href="mailto:david.melkumyan@desy.de">David Melkumyan</a>
   * 
   * @version $Id: Templates.xml,v 1.10 2008/06/23 15:30:13 sweisse Exp $
   * 
   */
  public final class TineHandler implements TLinkCallback {
  
  	private static final String LOGGER_NAME = "TineVideo";
  
  	/**
  	 * error code of 607 means for VSv2: currently no new image to be
  	 * transferred (e.g. timeout on schedule)
  	 */
  	private static final int V2CODE_NO_DATA = 607;
  
  	/**
  	 * error code of 516 means for VSv3: currently no new image to be
  	 * transferred (e.g. timeout on schedule)
  	 */
  	private static final int V3CODE_NO_DATA = 516;
  
  	/** will get the prearranged images for further use. */
  	private TineImageReceiver receiver;
  
  	/**
  	 * temporary storage of next successfully received video image from TINE,
  	 * also used to wrap VSv2 data blob as VSv3 image.
  	 */
  	private IMAGE srcImage;
  
  	/** VSv2 raw bits buffer. */
  	private byte[] srcBufV2;
  
  	/** TINE video data transmission link. */
  	private TLink tlink;
  
  	/** is a video data transfer running? */
  	private boolean isTransfering;
  
  	/** should the ImageDisplayer be reset on next callback? */
  	private boolean isResetReceiver;
  
  	/** is a VSv3 transfer ongoing? */
  	private boolean isTransferV3 = true;
  
  	/** is an array image */
  	private boolean isAImage = false;
  
  	public static final Logger logger;
  
  	static {
  		logger = Logger.getLogger(LOGGER_NAME);
  		LogFormatter formatter = new LogFormatter();
  		Handler handler = new StreamHandler(System.out, formatter) {
  			@Override
  			public synchronized void publish(LogRecord record) {
  				super.publish(record);
  				flush();
  			}
  		};
  		handler.setLevel(Level.INFO);
  		logger.setLevel(Level.INFO);
  		Handler[] handlers = logger.getHandlers();
  		for (Handler h : handlers) {
  			logger.removeHandler(h);
  		}
  		logger.addHandler(handler);
  		logger.setUseParentHandlers(false);
  	}
  
  	/** Constructor. The instance must always have a valid receiver-reference. */
  	public TineHandler(TineImageReceiver receiver) {
 		this.receiver = receiver;
 	}
 
 	/**
 	 * TINE callback implemented via TLinkCallback. It is called for each event
 	 * on an asynchronous connection between image source and TineHandler class.
 	 * Events can be new image delivery and error on image delivery property.
 	 * 
 	 */
 	public void callback(TLink tlink) {
 		logger.log(Level.FINE, "Tine Handler: update received.");
 		if (!isTransfering) {// accidental callback-call
 			logger.log(Level.INFO, "Tine Handler: Invalid update.");
 			return;
 		}
 
 		int cc = tlink.getLinkStatus();
 		if (cc != 0) {
 			logger.log(isNoData(cc) ? Level.INFO : Level.WARNING, //
 					"Tine Handler: addr = \"/" + tlink.getFullDeviceNameAndProperty() // 
 							+ "\", code = " + tlink.getLinkStatus() //
 							+ ", msg = \"" + tlink.getLastError() + "\"");
 			return;
 		}
 
 		if (isTransferV3 == false) { // is currently a VsV2 transfer?
 			// a good VSv2 blob was received, so marshal it inside a VSv3
 			// object
 			// if no error happens on marshalling, pass further downstream
 			VideoHeaderV2 vidH2 = new VideoHeaderV2();
 
 			// do trick for camera port name, as it is not delivered with
 			// oldfashioned VideoSystem v2 header
 			String vidFrom = "'V2:/" + tlink.getContext() + "/" + tlink.getDeviceServer() + "'";
 
 			// "real" marshaling
 			if (!vidH2.packageV2BlobIntoIMAGE(vidFrom, srcBufV2, srcImage)) { // error
 				logger.log(Level.WARNING, "Tine Handler: Videotype V2 conversion failed, addr = " + vidFrom);
 				System.err.println("Videotype V2 conversion failed, addr = " + vidFrom);
 				return;
 			}
 		}
 
 		// on first call of callback method, the receiver is reset to allow
 		// proper initialization of variables for following transfer
 		if (isResetReceiver) {
 			receiver.resetForReceiving();
 			isResetReceiver = false;
 		}
 
 		// pass video image along to receiver component
 		receiver.updateValue(srcImage);
 	}
 
 	/**
 	 * Opens a one-time or permanent connection to an image source which can be
 	 * a VSv3 component with output interface like SGP and CoreProvider or a
 	 * VSv2 server like GrabServer2.
 	 * 
 	 * @param connParams
 	 *            - connection parameters
 	 * @throws ConnectionFailed
 	 */
 	public void openLink(ConnectionParameters connParams) throws ConnectionFailed {
 		if (connParams == null)
 			throw new NullPointerException("connParams == null!");
 		logger.log(Level.INFO, "Tine Handler: Connecting to " + connParams.getRemoteName() + ".");
 		TPropertyQuery[] infos = null;
 		try {
 			infos = TQuery.getPropertyInformation(connParams.getDeviceContext(), // 
 					connParams.getDeviceGroup(), //
 					connParams.getDeviceName(), //
 					connParams.getDeviceProperty());
 
 		} catch (Exception e) {
 			throw new ConnectionFailed("Probing Address did not succeed.", null);
 		}
 
 		if (infos == null || infos.length == 0)
 			throw new ConnectionFailed("Probing Address did not succeed.", null);
 
 		short type = infos[0].prpFormat;
 		int size = infos[0].prpSize;
 
 		switch (type) {
 		case TFormat.CF_BYTE:
 			if (size <= 1)
 				throw new ConnectionFailed("Illegal property data size: " + size, null);
 			size -= VideoHeaderV2.HDRSIZE;
 			isTransferV3 = false;
 			break;
 
 		case TFormat.CF_AIMAGE:
 			isAImage = true;
 
 		case TFormat.CF_IMAGE:
 			isTransferV3 = true;
 			break;
 
 		default:
 			throw new ConnectionFailed("Unsupported data type: " + TFormat.toString(type), null);
 		}
 
 		// create proper VSv3 buffer for
 		// (a) receiving of VSv3 images
 		// (b) passing along transformed VSv2 images to ImageDisplayer as VSv3
 		// image
 		// TODO sort out the length: prp.size is 10 times too large
 		// srcImage = new IMAGE(V2_TRANSPORT_LENGTH);
 		srcImage = new IMAGE(size);
 
 		// reset the receiver component on first successful callback!
 		isResetReceiver = true;
 
 		// create tine link
 		String address = "/" + connParams.getDeviceContext() + "/" + connParams.getDeviceGroup() //
 				+ "/" + connParams.getDeviceName() + "/" + connParams.getDeviceProperty();
 
 		if (!isTransferV3) { // Vs2 data transferring
 			int buffSize = size + VideoHeaderV2.HDRSIZE;
 			if (srcBufV2 == null || srcBufV2.length != buffSize)
 				srcBufV2 = new byte[buffSize];
 			tlink = new TLink(address, new TDataType(srcBufV2), null, TAccess.CA_READ);
 
 		} else
 			// Vs3 data transferring
 			tlink = new TLink(address, //
 					isAImage ? new TDataType(new IMAGE[] { srcImage }) : new TDataType(srcImage), //
 					null, //
 					TAccess.CA_READ);
 
 		// construct proper mode integer for attaching the link
 		short tMode;
 		switch (connParams.getAccessMode()) {
 		case POLL:
 			tMode = TMode.CM_POLL;
 			break;
 		case POLL_NETWORK:
 			tMode = TMode.CM_POLL | TMode.CM_MCAST;
 			break;
 		case POLL_CONNECT:
 			tMode = TMode.CM_POLL | TMode.CM_CONNECT;
 			break;
 		case READ:
 			tMode = TMode.CM_SINGLE;
 			break;
 		default:
 			throw new IllegalArgumentException("Illegal AccessMode: " + connParams.getAccessMode());
 		}
 
 		if (tlink.attach(tMode, this, connParams.getAccessRate()) < 0) {
 			tlink.cancel();
 			tlink = null;
 			throw new ConnectionFailed("No permanent connection to server (\"" + tlink.getLastError() + "\".", null);
 		}
 		logger.log(Level.INFO, "Tine Handler: Link established.");
 		isTransfering = true;
 	}
 
 	/**
 	 * Return true if no new image, otherwise false
 	 * 
 	 * @param cc
 	 *            - error code
 	 * @return true if no new image, otherwise false
 	 */
 	private boolean isNoData(int cc) {
 		return isTransferV3 ? (cc == V3CODE_NO_DATA) : (cc == V2CODE_NO_DATA);
 	}
 
 	/**
 	 * used to cancel a running transfer. Designed to work even in case no
 	 * transfer was started at all.
 	 * 
 	 */
 	public void closeLink() {
 		logger.log(Level.INFO, "Tine Handler: Disconnecting.");
 		if (tlink != null) {
 			tlink.close();
 			tlink = null;
 		}
 		isTransfering = false;
 	}
 
 	// commented: mdavid
 	// private String printError(TLink link) {
 	// String retVal = "Link Error: addr = \"/" +
 	// link.getFullDeviceNameAndProperty() //
 	// + "\", code = " + link.getLinkStatus() //
 	// + ", msg = \"" + link.getLastError() + "\"";
 	// System.err.println(retVal);
 	// return retVal;
 	// }
 }