/*
 * TCPReceiveAdapter.java
 *
 * Created on November 19, 2003, 11:55 AM
 */

package gov.nist.applet.phone.media.protocol.transport;

import java.io.IOException;
import java.net.Socket;

import javax.media.protocol.PushSourceStream;
import javax.media.rtp.RTPConnector;
import javax.media.rtp.OutputDataStream;
/**
 * An implementation of RTPConnector based on TCP sockets.
 * This implementation can only receive RTP data.
 * @author  DERUELLE Jean
 */
public class TCPReceiveAdapter  implements RTPConnector {
    private Socket remoteSocket;
    private Socket remoteCtrlSocket; 
    
    /*private ServerSocket serverSocket;
    private ServerSocket ctrlServerSocket;
    
    private InetAddress addr;
    private int localPort;            
    private int rtcpLocalPort;    */

    private TCPPushSourceStream dataInStrm = null, ctrlInStrm = null;
    private TCPOutputDataStream dataOutStrm = null, ctrlOutStrm = null;
    /** Creates a new instance of TCPReceiveAdapter 
     * @param addr - address of the remote host
     * @param localPort - port of the local host
     * @param destPort - port of the remote host
     */
    /*public TCPReceiveAdapter(InetAddress addr, int localPort, int destPort) throws IOException  {
        this(addr, localPort, destPort, 1);
    }*/
    
    /** Creates a new instance of TCPReceiveAdapter 
     * @param addr - address of the remote host
     * @param localPort - port of the local host
     * @param destPort - port of the remote host
     * @param ttl - time to live
     */
    /*public TCPReceiveAdapter(InetAddress addr, int localPort, int destPort, int ttl) throws IOException {
        try {	    
            //Start the serverSocket for the RTP 
            serverSocket = new ServerSocket(localPort);
        } catch(SocketException e) {
            System.out.println(addr+","+localPort+","+destPort);
	    throw new IOException(e.getMessage());
	}        
        System.out.println("TCP Listening Point created on port: "+localPort);
        TCPConnectionListener listener=new TCPConnectionListener(serverSocket, this,  false);
        listener.start();
        rtcpLocalPort=localPort+1;        
        try{
            //Start the serverSocket for the RTCP 
            ctrlServerSocket = new ServerSocket(rtcpLocalPort);
        } catch(SocketException e) {
            System.out.println(addr+","+rtcpLocalPort+","+destPort);
	    throw new IOException(e.getMessage());
	}        
        System.out.println("TCP Control Listening Point created on port: "+rtcpLocalPort);
        TCPConnectionListener ctrlListener=new TCPConnectionListener(ctrlServerSocket, this,  true);
        ctrlListener.start();
        //Wait for connections
        listener.waitForConnections();
        ctrlListener.waitForConnections(); 
	
	this.addr = addr;
	this.localPort = localPort;        
    }*/
    
    /** Creates a new instance of TCPReceiveAdapter 
     * @param socketRTP - socket for receiveing RTP media 
     * already connected to the remote host
     * @param socketRTCP - socket for receiveing RTCP media 
     * already connected to the remote host
     */
    public TCPReceiveAdapter(Socket socketRTP,Socket socketRTCP) {
        this.remoteSocket=socketRTP;
        this.remoteCtrlSocket=socketRTCP;
    }
    
    /**
     * Returns an input stream to receive the RTP data.
     * @return input stream to receive the RTP data.
     */
    public PushSourceStream getDataInputStream() throws IOException {
	if (dataInStrm == null) {
	    dataInStrm = new TCPPushSourceStream(remoteSocket,false);            
	    dataInStrm.start();
	}
	return dataInStrm;
    }

    /**
     * Returns an output stream to send the RTP data.
     * @return output stream to send the RTP data.
     */
    public OutputDataStream getDataOutputStream() throws IOException {
	if (dataOutStrm == null)
	    dataOutStrm = new TCPOutputDataStream(remoteSocket,false);            
	return dataOutStrm;
    }

    /**
     * Returns an input stream to receive the RTCP data.
     * @return input stream to receive the RTCP data.
     */
    public PushSourceStream getControlInputStream() throws IOException {
	if (ctrlInStrm == null) {
	    ctrlInStrm = new TCPPushSourceStream(remoteCtrlSocket,true);            
	    ctrlInStrm.start();
	}
	return ctrlInStrm;
    }

    /**
     * Returns an output stream to send the RTCP data.
     * @return output stream to send the RTCP data.
     */
    public OutputDataStream getControlOutputStream() throws IOException {	
	if (ctrlOutStrm == null)
	    ctrlOutStrm = new TCPOutputDataStream(remoteCtrlSocket,true);            
	return ctrlOutStrm;
    }

    /**
     * Close all the RTP, RTCP streams.
     */
    public void close() {
	if (dataInStrm != null)
	    dataInStrm.kill();
	if (ctrlInStrm != null)
	    ctrlInStrm.kill();
        /*try{
            serverSocket.close();
        }
        catch(IOException ioe){
            ioe.printStackTrace();
        }
        try{
            ctrlServerSocket.close();
        }
        catch(IOException ioe){
            ioe.printStackTrace();
        }*/
        try{
            remoteSocket.close();
        }
        catch(IOException ioe){
            ioe.printStackTrace();
        }
        try{
            remoteCtrlSocket.close();
        }
        catch(IOException ioe){
            ioe.printStackTrace();
        }
    }

    /**
     * Set the receive buffer size of the RTP data channel.
     * This is only a hint to the implementation.  The actual implementation
     * may not be able to do anything to this.
     * @param size - receive buffer size 
     */
    public void setReceiveBufferSize( int size) throws IOException {
	remoteSocket.setReceiveBufferSize(size);        
    }

    /**
     * Get the receive buffer size set on the RTP data channel.
     * Return -1 if the receive buffer size is not applicable for
     * the implementation.
     * @return receive buffer size 
     */
    public int getReceiveBufferSize() {
	try {
	    return remoteSocket.getReceiveBufferSize();            
	} catch (Exception e) {
	    return -1;
	}
    }

    /**
     * Set the send buffer size of the RTP data channel.
     * This is only a hint to the implementation.  The actual implementation
     * may not be able to do anything to this.
     * @param size - send buffer size.
     */
    public void setSendBufferSize( int size) throws IOException {
	remoteSocket.setSendBufferSize(size);        
    }

    /**
     * Get the send buffer size set on the RTP data channel.
     * Return -1 if the send buffer size is not applicable for
     * the implementation.
     * @return send buffer size 
     */
    public int getSendBufferSize() {
	try {
	    return remoteSocket.getSendBufferSize();            
	} catch (Exception e) {
	    return -1;
	}
    }

    /**
     * Return the RTCP bandwidth fraction.  This value is used to
     * initialize the RTPManager.  Check RTPManager for more detauls.
     * @return RTCP bandwidth fraction. -1 to use the default values.
     */
    public double getRTCPBandwidthFraction() {
	return -1;
    }

    /**
     * Return the RTCP sender bandwidth fraction.  This value is used to
     * initialize the RTPManager.  Check RTPManager for more detauls.
     * Return -1 to use the default values.
     * @return RTCP sender bandwidth fraction. -1 to use the default values.
     */
    public double getRTCPSenderBandwidthFraction() {
	return -1;
    }
    
    /**
     * Set the remote socket connected to this Adapter TCP Listening port 
     * @param socket - remote socket connected to this Adapter TCP Listening port 
     * @param ctrl - tells if this socket is for the RTP or RTCP
     */
    public void setRemoteSocket(Socket socket, boolean ctrl){
        if(ctrl)
            this.remoteCtrlSocket=socket;
        else
            this.remoteSocket=socket;
    }
    
}