package de.desy.video.sw;
   
   import com.cosylab.gui.components.util.RunnerHelper;
   
   import de.desy.acop.transport.AccessMode;
   import de.desy.acop.transport.ConnectionFailed;
   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.TMode;
  import de.desy.tine.types.IMAGE;
  import de.desy.tine.queryUtils.TPropertyQuery;
  import de.desy.tine.queryUtils.TQuery;
  import de.desy.tine.startup.TInitializer;
  import de.desy.tine.startup.DefaultTInitializerFactory;
  import de.desy.tine.startup.TInitializerFactory;
  
  /**
  * <code>TineHandler</code> encapsulates and divides reception of VSv3 and VSv2 image streams 
  * from displaying class ImageDisplayer. 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>
  * @version $Id: Templates.xml,v 1.10 2008/06/23 15:30:13 sweisse Exp $
  *
  */
  public final class TineHandler implements TLinkCallback {
  
  	/** will get the prearranged images for further use. */
  	private ImageDisplayer displayer;
  	
  	/** temporary storage of next successfully received video image from TINE, also
  	 * used to wrap VSv2 data blob as VSv3 image. */
  	private IMAGE m_srcImgHdr;
  	
  	/** VSv3 image bits buffer, may also contain VSv2 marshalled bits. */
  	private byte[] m_srcBuf=null;
  	
  	/** VSv2 raw bits buffer. */
  	private byte[] m_srcBufV2=null;
  	
  	/** TINE video data transmission link. */
  	private TLink m_vidLink;
  	/** is a video data transfer running? */
  	private boolean m_bTransferRunning = false;
  	/** should the ImageDisplayer be reset on next callback? */
  	private boolean m_bResetDisplayer = false;
  	/** is a VSv3 transfer ongoing? */
  	private boolean m_bV3Transfer = true;
  	/** initial, default transport length of VSv2, might change substantially.*/
  	private int m_iTransportLengthV2 = 768*574*1+CVideoHeader2.HDRSIZE;
  	
  	/** defined (maximal) transport length for VSv3. */
  	private final int m_iTransportLengthV3 = CVideoHeader3.TRANSPORT_LENGTH_V3;
  	
  	/** Constructor. The instance must always have a valid displayer-reference. */
  	public TineHandler(ImageDisplayer displayer) {
  		this.displayer = displayer;
  	}
  
  	/**
  	 * 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 link) {
  		
  		// accidental callback-call, let's get outta here
  		if (!m_bTransferRunning) return;
  		
  		// is currently a VSv3 transfer?
  		if (m_bV3Transfer == true)
  		{
  			// error code of 516 means for VSv3: currently no new image to be transferred
  			// (e.g. timeout on schedule)
  			if (link.getLinkStatus() == 516)
  				return;
  
  			// any other error will give a debug print output to console and wait for next frame
  			// TODO why no System.err ?
  			if (link.getLinkStatus() != 0) {
  				System.out.println("Link Error : code=" + link.getLinkStatus() + " msg=" + link.getLastError());
  				return;
  			}
  		}
  		else
  		{
  			// error code of 607 means for VSv2: currently no new image to be transferred
  			// (e.g. timeout on schedule)
  			if (link.getLinkStatus() == 607) // VSV2 no data to send
  				return;
  
  			// any other error will give a debug print output to console and wait for next frame
  			// TODO why no System.err ?
  			if (link.getLinkStatus() != 0) {
  				System.out.println("Link Error : code=" + link.getLinkStatus() + " msg=" + link.getLastError());
  				return;
 			}
 
 			//TDataType out = link.getOutputDataObject();
 			//System.out.println("cc="+link.getLinkStatus()+" Completionlength="+out.dCompletionLength); 
 			
 			// a good VSv2 blob was received, so marshal it inside a VSv3 object
 			// if no error happens on marshalling, pass further downstream
 			CVideoHeader2 vidH2 = new CVideoHeader2();
 			
 			// do trick for camera port name, as it is not delivered with oldfashioned 
 			// VideoSystem v2 header
 			String vidFrom = "'V2:/"+link.getContext()+"/"+link.getDeviceServer()+"'";
 			
 			// "real" marshalling
 			boolean ret = vidH2.packageV2BlobIntoIMAGE(vidFrom, m_srcBufV2, m_srcImgHdr);
 			if (ret == false) // error while marshalling? error output and no passing along 
 			{
 				// DEBUG SW!
 				System.out.println("TINE Callback: Videotype V2 conversion unsuccessful");
 				return;
 			}
 			
 		}
 
 		// on first call of callback method, the displayer is reset to allow proper 
 		// initialisation of variables for following transfer
 		if (m_bResetDisplayer == true) {
 			displayer.resetForReceiving();
 			m_bResetDisplayer = false;
 		}
 		
 		// pass video image marshalled into CVideoHeader3 along to displayer component
 		displayer.updateValue(new CVideoHeader3(m_srcImgHdr));
 	}
 	
 	/**
 	 *	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 aAddress full qualified or incomplete TINE Address for VSv3 Output or VSv2 
 	 * server (either /Context/Server/ or /Context/Server/Device or Server/ or Server/Device)
 	 * @param mode TINE access mode (AccessMode.POLL usually) 
 	 * @param accessRate TINE polling rate 
 	 * @throws ConnectionFailed
 	 * @throws ImageException
 	 */
 	
 	public void openLink(String aAddress, AccessMode mode, int accessRate) throws Exception
 	{
 		String possiblyIncompleteTineDeviceName = aAddress;
 		String tineAddress;
 
 		// check image source connection and type, throw connection otherwise
 		m_bV3Transfer = probeTineV3andV2(possiblyIncompleteTineDeviceName); // SW! throw
 
 		// create proper VSv3 buffer for 
 		// (a) receiving of VSv3 images
 		// (b) passing along transformed VSv2 images to ImageDisplayer as VSv3 image
 		if (m_srcBuf == null)
 			m_srcBuf = new byte[m_iTransportLengthV3];
    
 		m_srcImgHdr = new IMAGE();
 		m_srcImgHdr.setImageFrameBuffer(m_srcBuf);
 		
 		// reset the displayer component on first successful callback!
 		m_bResetDisplayer = true;
 
 		// startup VSv3 transfer
 		if (m_bV3Transfer == true)
 		{
 			// create proper VSv3 link
 			tineAddress = getFullQualifiedV3Address( possiblyIncompleteTineDeviceName );
 			TDataType img_dout = new TDataType(m_srcImgHdr);
 			m_vidLink = new TLink(tineAddress,img_dout,null,TAccess.CA_READ);
 		}
 		else
 		{
 			// create proper VSv2 link
 			tineAddress = getFullQualifiedV2Address( possiblyIncompleteTineDeviceName );
 
 			// SW! workaround: returned data got cut down to 192 bytes (WTF?!) 
 			// SW! somehow if not +1 byte is asked
 			// SW! but only if really full transport length is transferred by V2 server
 			// SW! e.g. HFYU usually works, uncompressed transfers don't
 			int v2Size = m_iTransportLengthV2+1;
 			
 			// adjust buffer if not right
 			if (m_srcBufV2 == null || m_srcBufV2.length != v2Size)
 			{
 				m_srcBufV2 = new byte[v2Size]; 
 			}
 			
 			TDataType img_dout = new TDataType(m_srcBufV2);
 			m_vidLink = new TLink(tineAddress,img_dout,null,TAccess.CA_READ);
 		}
 
 		// construct proper mode integer for attaching the link 
 		short tMode;
 		if (mode == AccessMode.POLL) {
 			tMode = TMode.CM_POLL;			
 		} else if (mode == AccessMode.POLL_NETWORK)	{
 			tMode = TMode.CM_POLL | TMode.CM_MCAST;
 		} else if (mode == AccessMode.READ) {
 			tMode = TMode.CM_SINGLE;
 		} else {
 			throw new ConnectionFailed("Cannot establish a connection. AccessMode should be POLL or READ.", null);
 		}
 	    
 		if (m_vidLink.attach(tMode, this, accessRate) < 0)
 	    {
 	    	m_vidLink.cancel();
 	    	m_vidLink = null;
     	  
 	    	throw new ConnectionFailed("No permanent connection to server (\""+m_vidLink.getLastError()+"\".", null);
 	    }
 				
 	    m_bTransferRunning = true;
 	}
 
 	/**
 	 * used to cancel a running transfer. Designed to work even in case no transfer was 
 	 * started at all.
 	 *
 	 */
 	public void closeLink() {
 		if (m_vidLink != null) {
 			m_vidLink.cancel();
 			m_vidLink = null;
 		}
 		m_bTransferRunning = false;
 	}
 
 	
 	/** creates a full-qualified TINE VSv2 address out of a valid partial address.
 	 * 
 	 * 
 	 * @param aPartialAddress either /Context/Server/ or /Context/Server/Device or
 	 *        Server/ or Server/Device
 	 * @return "/Context/Server/device_0/FRAME.GET" or "Server/device_0/FRAME.GET"
 	 * 
 	 */
 	private String getFullQualifiedV2Address(String aPartialAddress)
 	{
 		String retval;
 		
 		retval = aPartialAddress;
 		if (retval.endsWith("/") == true) retval +="device_0";
 		retval += "/FRAME.GET";
 	
 		return retval;
 	}
 
 	/** creates a full-qualified TINE VSv3 address out of a valid partial address.
 	 * 
 	 * @param aPartialAddress either /Context/Server/ or /Context/Server/Device or
 	 *        Server/ or Server/Device
 	 * @return "/Context/Server/Output/Frame.Sched" or "Server/Output/Frame.Sched"
 	 * 
 	 */
 	private String getFullQualifiedV3Address(String aPartialAddress)
 	{
 		String retval;
 		
 		retval = aPartialAddress;
 		if (retval.endsWith("/") == true) retval +="Output";
 		retval += "/Frame.Sched";
 		return retval;
 	}
 
 	/** probes partial address passed whether there is a VSv3 connection or a VSv2 
 	 * data transport connection behind that. VSv3 is prefered over VSv2 in case
 	 * both are provided.<br><br> 
 	 * <b>Note: </b>In case of VSv2 transport this function is very important because 
 	 * it will adjust the VSv2 transport length to the VSv2 server's very own transport
 	 * length.
 	 * 
 	 * @param aPartialAddress either /Context/Server/ or /Context/Server/Device or
 	 *        Server/ or Server/Device
 	 * @return 
 	 * <ul>
 	 * <li>true in case of VSv3 transport
 	 * <li>false in case of VSv2 transport
 	 * </ul> 
 	 * @throws ConnectionFailed
 	 * @throws ImageException
 	 */
 	private boolean probeTineV3andV2(String aPartialAddress) throws Exception {
 
 		// construct appropriate local variables
 		byte[] framebits3 = new byte[CVideoHeader3.HDRSIZE];
 		String addressVSV2 = getFullQualifiedV2Address(aPartialAddress);
 		TDataType dout3 = new TDataType(framebits3);
 		
 		String devProp="Header";
 		if (aPartialAddress.endsWith("/")) aPartialAddress += "Output";
 
 		// test VSv3 connection using simple single synchronous execute call
 		// to acquire a VSv3 video header 
 		TLink ref = new TLink(aPartialAddress, devProp, dout3, null, TAccess.CA_READ);
 		int cc = ref.execute();
 		if (cc != 0) 
 		{
 			// here: return code not equal to 0 (success) is interpreted as 
 			// no VSv3 connection
 			
 			// check V2 from now on:
 
 			// prep: create proper settings for VSv2, split and recombine aPartialAddress,
 			// which was adapted before to full VSv3
 
 			String context = "DEFAULT";
 			String server = "";
 			String device = "device_0";
 			String property = "FRAME.GET";
 			
 			String[] list = aPartialAddress.split("/");
 			int l = list.length;
 				
 			if (l>0)
 			{
 				if (list[0].compareTo("") == 0)
 				{
 					if ((list.length>1) && (list[1].compareTo("") != 0)) context = list[1];
 					if ((list.length>2) && (list[2].compareTo("") != 0)) server = list[2];
 				}
 				else
 				{
 					server = list[0];
 				}
 			}
 
 			// first: get _real_ transport length of TINE v2:
 			
 			// will usually throw exception also in error case
 			TPropertyQuery[] propList = TQuery.getPropertyInformation(context,server,device,property);
 			
 			// no VSv3 and also no VSv2 transport detected, so throw exception
 			if (propList == null)
 			{
 				framebits3 = null;				
 				throw new ConnectionFailed("Probing Address did not succeed. Transfer was cancelled.", null);
 			}
 
 			// no VSv3 and also no VSv2 transport detected, so throw exception			
 			if (propList.length<1) 
 			{
 				framebits3 = null;				
 				throw new ConnectionFailed("Probing Address did not succeed. Transfer was cancelled.", null);
 			}
 
 			// VSv2 transport is detected, now test whether it _works_ 
 
 			// create special byte blob array of queried transport length 
 			m_iTransportLengthV2 = propList[0].prpSize;
 			byte [] framebits2 = new byte[m_iTransportLengthV2+1];
 			TDataType dout2 = new TDataType(framebits2);
 			
 			// get a single frame using synchronous method
 			TLink ref1 = new TLink(addressVSV2, dout2, null, TAccess.CA_READ);
 			int cc1 = ref1.execute();
 			
 			if ((cc1 == 0) || (cc1 == 607)) // success or currently_no_new_image 
 			{
 				// it is okay for us to have success (frame was send back) or
 				// error code 607, which means that currently there is no new image
 				// to download because both cases provide that also remote peer is
 				// working good enough for us
 				
 				// cancel transfer, reset arrays
 				ref1.cancel();
 				framebits2 = null;
 				framebits3 = null;				
 				
 				// return false to indicate that VSv2 was detected
 				return false;
 			}
 			
 			ref1.cancel();
 			framebits2 = null;
 			framebits3 = null;				
 			
 			// System.out.println("Error: get reference : " +
 			// ref.getLinkStatus());
 			// 517==RETCODE_NOFRAMEYET
 			
 			// bad VSv3, bad VSv2 -> throw Exception 
 			throw new ConnectionFailed("Probing Address did not succeed. Transfer was cancelled.", null);
 		} else {
 			
 			// good VSv3 connection, but check completionlength for array match,
 			// if bad throw Exception
 			
 			ref.cancel();
 			if (dout3.dCompletionLength != CVideoHeader3.HDRSIZE) {
 				throw new ImageException("CF_IMAGE header is not "+CVideoHeader3.HDRSIZE+" bytes in size. Transfer was cancelled.");
 			}
 		}
 
 		// success case for VSv3 connection, cleanup, return true to indicate VSv3 
 		// was chosen
 		framebits3 = null;		
 		return true;
 	}
 
 	/** example main for TineHandler plus ImageDisplayer. */
 	public static void main(String[] args) throws Exception 
 	{
 		// SW! Oct 01, 2008
 		//DefaultTInitializerFactory.getInstance().getInitializer().setClnRcvBufferSize(131072);
 		ImageDisplayer d = new ImageDisplayer();
 		TineHandler handler = new TineHandler(d);
 		handler.openLink("/TEST/SGP_IMM1", AccessMode.POLL, 1000);
 		RunnerHelper.runComponent(d, 800,600);
 	}
 }