/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.transport.adapters;
  
  import java.beans.Beans;
  import java.beans.PropertyVetoException;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Map;
  
  import com.cosylab.gui.displayers.CommonDisplayer;
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.DataSource;
  import com.cosylab.gui.displayers.DataSourceSupport;
  import com.cosylab.gui.displayers.DataState;
  import com.cosylab.gui.displayers.Displayer;
  import com.cosylab.gui.displayers.DoubleSeqConsumer;
  import com.cosylab.gui.displayers.StringConsumer;
  import com.cosylab.gui.displayers.StringSeqConsumer;
  import com.cosylab.util.ObjectList;
  
  import de.desy.acop.transport.AcopTransport;
  import de.desy.acop.transport.AcopTransportEvent;
  import de.desy.acop.transport.AcopTransportListener;
  import de.desy.acop.transport.ConnectionFailed;
  import de.desy.acop.transport.ConnectionParameters;
  import de.desy.tine.definitions.TArrayType;
  import de.desy.tine.definitions.TErrorList;
  import de.desy.tine.definitions.TFormat;
  import de.desy.tine.queryUtils.TQuery;
  import de.desy.tine.types.NAME16;
  import de.desy.tine.types.NAME32;
  import de.desy.tine.types.NAME64;
  import de.desy.tine.types.USTRING;
  
  
  /**
   * <code>AcopTransportDataSource</code> is a common DataSource for all TINE based
   * connections. This class connects to the TINE CS via the <code>AcopTransport</code>.
   * This data source works as a connection monitor receiving data as specified
   * by the supplied <code>ConnectionParameters</code>.
   * 
   * @author Igor Kriznar (igor.kriznarATcosylab.com)
   *
   */
  public class AcopTransportDataSource extends DataSourceSupport implements AcopTransportListener {
  
  	private static final long serialVersionUID = -6371576395329401933L;
  	int useCount = 0;
  	protected ObjectList dcon= new ObjectList(DoubleSeqConsumer.class);
  	protected ObjectList scon = new ObjectList(StringConsumer.class);
  	protected ObjectList sseqcon = new ObjectList(StringSeqConsumer.class);
  	private AcopTransport transport;
  	private int id=-1;
  	protected double[] data;
  	protected String[] objectData;
  	private Object inData;
  	private long timestamp;
  	private Map<String,Object> characteristics;
  	private ConnectionParameters param;
  	private ReverseConsumer reverseConsumer;
  	private TFormat dataFormat;
  	private int errorId=-1;
  	private DataState dataState = new DataState(DataState.UNDEFINED);
  
  	/**
  	 * Creates new instance of AcopTransportDataSource.
  	 */
  	@SuppressWarnings("unchecked")
  	public AcopTransportDataSource() {
  		super(new Class[]{DoubleSeqConsumer.class});
  		transport= new AcopTransport();
          transport.addAcopTransportListener(this);
  	}
  	
  	/* (non-Javadoc)
  	 * @see com.cosylab.gui.displayers.DataSourceSupport#addConsumer(com.cosylab.gui.displayers.DataConsumer)
  	 */
  	@Override
 	public void addConsumer(DataConsumer consumer) throws PropertyVetoException {
 		DataConsumer dc = consumer.getDefaultDataConsumer();
 		
 		if (dc instanceof StringConsumer) {
 			scon.add(dc);
 			super.addConsumer(consumer);
 			
 		} else if (dc instanceof StringSeqConsumer) {
 			sseqcon.add(dc);
 			super.addConsumer(consumer);
 			
 		} else {
 			dc = consumer.getDataConsumer(DoubleSeqConsumer.class);
 			
 			if (dc==null) {
 				return;
 			}
 			dcon.add(dc);
 			super.addConsumer(consumer);
 			
 		}
 		
 		
 		try {
 			Map<String, Object> ch = null;
 			
 			if (!Beans.isDesignTime()) {
 				ch= getCharacteristics();
 			} else if (param != null){
 				ch = new HashMap<String, Object>();
 				ch.put(CommonDisplayer.C_DISPLAY_NAME,param.getRemoteName());	
 			}
 			if (ch!=null) {
 				consumer.setCharacteristics(ch);
 			}
 		} catch (ConnectionFailed e) {
 			e.printStackTrace();
 		}
 		
 		if (consumer instanceof DataSource) {
 			if (dataFormat.getValue() != TFormat.CF_USTRING &&
 					dataFormat.getValue() != TFormat.CF_NAME8 &&
 					dataFormat.getValue() != TFormat.CF_NAME16 &&
 					dataFormat.getValue() != TFormat.CF_NAME32 &&
 					dataFormat.getValue() != TFormat.CF_NAME64) {
 				((DataSource)consumer).addConsumer(getReverseConsumer());
 			} else {
 				Map<String, Object> ch = new HashMap<String, Object>();
 				ch.put(Displayer.C_EDITABLE, false);
 				consumer.setCharacteristics(ch);
 			}
 		}		
 		
 		consumer.updateDataState(dataState);
 	}	
 	
 	/**
 	 * Returns the characteristics that belong to the property specified by
 	 * the ConnectionParameters attached to this data source.
 	 * 
 	 * @return a Map of all characteristics, where keys are the name of the
 	 * 			characteristics and values are characteristics
 	 * @throws ConnectionFailed if property information query failed
 	 * @see DataSourceUtilities#getCharacteristics(ConnectionParameters)
 	 */
 	public Map<String,Object> getCharacteristics() throws ConnectionFailed {
 		if (characteristics == null && param!=null) {
 			characteristics = DataSourceUtilities.getCharacteristics(param);		
 		}
 		return characteristics;
 	}
 
 	/**
 	 * Returns the transport used by this data source.
 	 * 
 	 * @return the transport
 	 */
 	public AcopTransport getTransport() {
 		return transport;
 	}
 	
 	/**
 	 * Returns the <code>ConnectionParameters</code> attached to this data source.
 	 * 
 	 * @return the connection parameters
 	 */
 	public ConnectionParameters getConnectionParameters() {
 		return param;
 	}
 
 	/**
 	 * Connects this data source to the TINE channel.
 	 * 
 	 * @param conn parameters specifiyng the connection channel
 	 * @throws ConnectionFailed if remote connection failed
 	 */
 	public void connect(ConnectionParameters conn) throws ConnectionFailed {
 		param=conn;
 		
 		transport.setConnectionParameters(conn);
 		int size = conn.getPropertySize();
 		//TODO why this block??
 		if ((size == ConnectionParameters.ACTUAL_PROPERTY_SIZE ||
 				size == ConnectionParameters.AUTO_PROPERTY_SIZE) && 
 				(Integer)getCharacteristics().get(CommonDisplayer.C_SEQUENCE_LENGTH) > 1 &&
 				!((TArrayType)getCharacteristics().get("arrayType")).isChannel()) {
 			size = (Integer)getCharacteristics().get(CommonDisplayer.C_SEQUENCE_LENGTH);
 		}
 		if (size == ConnectionParameters.ACTUAL_PROPERTY_SIZE ||
 				size == ConnectionParameters.AUTO_PROPERTY_SIZE) {
 			if (!param.getDeviceName().contains("*")) {
 				size= (Integer)getCharacteristics().get(CommonDisplayer.C_SEQUENCE_LENGTH);
 			} else {
 				String[] names = TQuery.getDeviceNames(conn.getDeviceContext(), conn.getDeviceGroup());
 				size = names.length;
 			}
 		} 
 		if (param.getDeviceProperty().contains("*")) {
 			dataFormat = TFormat.valueOf(TFormat.CF_USTRING);
 		} else {
 			dataFormat = (TFormat)getCharacteristics().get("dataFormat");
 		}
 		inData= DataSourceUtilities.getDataObject(dataFormat,size);
 					
 		if (inData instanceof double[]) {
 			data= (double[])inData;
 		} else if (inData instanceof USTRING[] || inData instanceof NAME64[] ||
 				inData instanceof NAME32[] || inData instanceof NAME16[]) {
 			objectData= new String[size];		
 		} else {
 			data= new double[size];
 		}
 		
 		if (!Beans.isDesignTime()) {
 			id = transport.attachLink(inData, conn.getDynamicParameters());
 			if (id < 0) {
 				updateDataState(new DataState(DataState.ERROR));
 			}
 		}
 		updateCharacteristics();
 	}
 	
 	/**
 	 * Disconnects this data source from the remote TINE channel.
 	 *
 	 */
 	public void disconnect() {
 		if (!Beans.isDesignTime()) {
 			transport.closeLink(id);
 			clear();
 			if (getReverseConsumer() != null)
 				getReverseConsumer().release();
 	    	reverseConsumer=null;
 		}
 		clear();
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see de.desy.acop.transport.AcopTransportListener#dataEventReceived(de.desy.acop.transport.AcopTransportEvent)
 	 */
     public void dataEventReceived(AcopTransportEvent e)
     {
       int id = e.getLinkId();
       if (id != this.id) 
     	  return;
       int error = e.getLinkError();
       timestamp = DataSourceUtilities.toUTC(transport.getDataTimeStamp());
 
       if (error!=errorId) {
     	  errorId=error;
     	 
     	  if (error==0) {
     		  dataState= new DataState(DataState.NORMAL,timestamp,TErrorList.toString(error));
     	  } else {
     		  dataState= new DataState(DataState.ERROR,timestamp,TErrorList.toString(error));
     	  }
           updateDataState(dataState);
           
       }
       
       updateConsumers();   
     }
     
     private void updateConsumers() {
     	//System.out.println(">> "+Arrays.toString(data));
     	if (dataFormat.getValue() == TFormat.CF_USTRING ||
     			dataFormat.getValue() == TFormat.CF_NAME8 ||
     			dataFormat.getValue() == TFormat.CF_NAME16 ||
     			dataFormat.getValue() == TFormat.CF_NAME32 ||
     			dataFormat.getValue() == TFormat.CF_NAME64) {
     		objectData = DataSourceUtilities.extractData(dataFormat,inData,objectData);
     		StringConsumer[] sc= (StringConsumer[])scon.toArray();
     		
     		String data = "";
     		if (objectData != null) {
     			if (objectData.length == 1) {
     				data = objectData[0];
     			} else if (objectData.length > 1) {
     				data = Arrays.toString(objectData);
     			}
     		}
     			
         	for (int i = 0; i < sc.length; i++) {
     			try {
     				sc[i].updateValue(timestamp,data);
     			} catch (Exception e) {
     				e.printStackTrace();
     			}
     		}
         	
         	StringSeqConsumer[] ssc= (StringSeqConsumer[])sseqcon.toArray();
         	for (int i = 0; i < ssc.length; i++) {
     			try {
     				ssc[i].updateValue(timestamp,objectData);
     			} catch (Exception e) {
     				e.printStackTrace();
     			}
     		}
     	} else {
     		data= DataSourceUtilities.extractData(dataFormat,inData,data);
     		DoubleSeqConsumer[] dsc= (DoubleSeqConsumer[])dcon.toArray();
         	for (int i = 0; i < dsc.length; i++) {
     			try {
     				dsc[i].updateValue(timestamp,data);
     			} catch (Exception e) {
     				e.printStackTrace();
     			}
     		}
         	StringConsumer[] sc= (StringConsumer[])scon.toArray();
         	for (int i = 0; i < sc.length; i++) {
     			try {
     				sc[i].updateValue(timestamp,Arrays.toString(data));
     			} catch (Exception e) {
     				e.printStackTrace();
     			}
     		}
         	
         	StringSeqConsumer[] ssc= (StringSeqConsumer[])sseqcon.toArray();
         	for (int i = 0; i < ssc.length; i++) {
     			try {
     				ssc[i].updateValue(timestamp,DataSourceUtilities.toStringData(data));
     			} catch (Exception e) {
     				e.printStackTrace();
     			}
     		}
     	}
     	
     }
 
     private void updateCharacteristics() {
 		try {
 			Map ch= getCharacteristics();
 			DataConsumer[] dsc= (DataConsumer[])dcon.toArray();
 			for (int i = 0; i < dsc.length; i++) {
 				try {
 					dsc[i].setCharacteristics(ch);
 				} catch (Exception e) {
 					e.printStackTrace();
 				}
 			}
 		} catch (ConnectionFailed e) {
 			e.printStackTrace();
 		}
     }
     
     /**
      * Returns the consumer that is attached to the displayer and enables setting
      * value on the channel specified by the ConnectionParameters of this data source.
      * 
      * @return
      */
     protected ReverseConsumer getReverseConsumer() {
     	if (reverseConsumer == null) {
     		if (data != null)
     			reverseConsumer = new ReverseConsumer(param,transport,data.length);
 		}
 
 		return reverseConsumer;
     }
     
     /* (non-Javadoc)
      * @see com.cosylab.gui.displayers.DataSourceSupport#clear()
      */
     @Override
     public void clear() {
     	DataConsumer[] cc= getConsumers();
     	for (DataConsumer c:cc) {
     		if (c instanceof DataSource) {
     			((DataSource)c).removeConsumer(getReverseConsumer());
     		}
     	}
     	super.clear();
     }
 
 	
 	/**
 	 * Returns the format.
 	 * @return Returns the format.
 	 */
     protected TFormat getDataFormat() {
 		return dataFormat;
 	}
 
 	
 	/**
 	 * Sets new format.
 	 * @param format The format to set.
 	 */
 	protected void setDataFormat(TFormat format) {
 		this.dataFormat = format;
 	}
 	
 	/**
 	 * Updates DataState on all consumers.
 	 * 
 	 * @param state new data state
 	 */
 	private void updateDataState(DataState state) {
 		DataConsumer[] delegates = getConsumers();
 	
 		for (int i = 0; i < delegates.length; i++) {
 			try {
 				delegates[i].updateDataState(state);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 	
 	/**
 	 * Removes the <code>DataConsumer</code> from this data source. 
 	 */
 	public void removeConsumer(DataConsumer consumer) {
 		super.removeConsumer(consumer);
 		dcon.remove(consumer);
 		scon.remove(consumer);
 		sseqcon.remove(consumer);
 		if (consumer instanceof DataSource && 
 				(dataFormat.getValue() != TFormat.CF_USTRING ||
 				 dataFormat.getValue() != TFormat.CF_NAME8 ||
 				 dataFormat.getValue() != TFormat.CF_NAME16 ||
 				 dataFormat.getValue() != TFormat.CF_NAME32 ||
 				 dataFormat.getValue() != TFormat.CF_NAME64)) {
 			((DataSource)consumer).removeConsumer(getReverseConsumer());
 		} 
 		
 	}
 	
 	/**
 	 * Returns the length of data received from the remote channel.
 	 * 
 	 * @return
 	 */
 	protected int getDataLength() {
 		return data.length;
 	}
 
 }