/**

 * Java RTP Library (jlibrtp)

 * Copyright (C) 2006 Arne Kepp

 * 

 * 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 jlibrtp;

import java.net.DatagramPacket;

import java.net.InetSocketAddress;

import java.util.*;

/**

 * This thread sends scheduled RTCP packets 

 * 

 * It also performs maintenance of various queues and the participant

 * database.

 * 

 * @author Arne Kepp

 *

 */

public class RTCPSenderThread extends Thread {

	/** Parent RTP Session */

	private RTPSession rtpSession = null;

	/** Parent RTCP Session */

	private RTCPSession rtcpSession = null;

	/** Whether we have sent byes for the last conflict */

	private boolean byesSent = false;

	/**

	 * Constructor for new thread

	 * @param rtcpSession parent RTCP session

	 * @param rtpSession parent RTP session

	 */

	protected RTCPSenderThread(RTCPSession rtcpSession, RTPSession rtpSession) {

		this.rtpSession = rtpSession;

		this.rtcpSession = rtcpSession;

		if(RTPSession.rtpDebugLevel > 1) {

			System.out.println("<-> RTCPSenderThread created");

		} 

	}

	/**

	 * Send BYE messages to all the relevant participants

	 *

	 */

	protected void sendByes() {

		// Create the packet

		CompRtcpPkt compPkt = new CompRtcpPkt();

		//Need a SR for validation

		RtcpPktSR srPkt = new RtcpPktSR(this.rtpSession.ssrc, 

				this.rtpSession.sentPktCount, this.rtpSession.sentOctetCount, null);

		compPkt.addPacket(srPkt);

		byte[] reasonBytes;

		//Add the actualy BYE Pkt

		long[] ssrcArray = {this.rtpSession.ssrc};

		if(rtpSession.conflict) {

			reasonBytes = "SSRC collision".getBytes();

		} else {

			reasonBytes = "jlibrtp says bye bye!".getBytes();

		}

		RtcpPktBYE byePkt = new RtcpPktBYE( ssrcArray, reasonBytes);

		compPkt.addPacket(byePkt);

		// Send it off

		if(rtpSession.mcSession) {

			mcSendCompRtcpPkt(compPkt);

		} else {

			Iterator<Participant> iter = rtpSession.partDb.getUnicastReceivers();

			while(iter.hasNext()) {

				Participant part = (Participant) iter.next();

				if(part.rtcpAddress != null)

					sendCompRtcpPkt(compPkt, part.rtcpAddress);

			}

			//System.out.println("SENT BYE PACKETS!!!!!");

		}

	}

	/**

	 * Multicast version of sending a Compound RTCP packet

	 * 

	 * @param pkt the packet to best

	 * @return 0 is successful, -1 otherwise

	 */

	protected int mcSendCompRtcpPkt(CompRtcpPkt pkt) {

		byte[] pktBytes = pkt.encode();

		DatagramPacket packet;

		// Create datagram

		try {

			packet = new DatagramPacket(pktBytes,pktBytes.length,rtpSession.mcGroup,rtcpSession.rtcpMCSock.getPort());

		} catch (Exception e) {

			System.out.println("RCTPSenderThread.MCSendCompRtcpPkt() packet creation failed.");

			e.printStackTrace();

			return -1;

		}

		// Send packet

		if(RTPSession.rtcpDebugLevel > 5) {

			System.out.println("<-> RTCPSenderThread.SendCompRtcpPkt() multicast");

		}

		try {

			rtcpSession.rtcpMCSock.send(packet);

			//Debug

			if(this.rtpSession.debugAppIntf != null) {

				this.rtpSession.debugAppIntf.packetSent(3, (InetSocketAddress) packet.getSocketAddress(), 

						new String("Sent multicast RTCP packet of size " + packet.getLength() + 

								" to " + packet.getSocketAddress().toString() + " via " 

								+ this.rtcpSession.rtcpMCSock.getLocalSocketAddress().toString()));

			}

		} catch (Exception e) {

			System.out.println("RCTPSenderThread.MCSendCompRtcpPkt() multicast failed.");

			e.printStackTrace();

			return -1;

		}

		return packet.getLength();

	}

	/**

	 * Unicast version of sending a Compound RTCP packet

	 * 

	 * @param pkt the packet to best

	 * @param receiver the socket address of the recipient

	 * @return 0 is successful, -1 otherwise

	 */

	protected int sendCompRtcpPkt(CompRtcpPkt pkt, InetSocketAddress receiver) {

		byte[] pktBytes = pkt.encode();

		DatagramPacket packet;

		//Create datagram

		try {

			//System.out.println("receiver: " + receiver);

			packet = new DatagramPacket(pktBytes,pktBytes.length,receiver);

		} catch (Exception e) {

			System.out.println("RCTPSenderThread.SendCompRtcpPkt() packet creation failed.");

			e.printStackTrace();

			return -1;

		}

		//Send packet

		if(RTPSession.rtcpDebugLevel > 5) {

			Iterator<RtcpPkt> iter = pkt.rtcpPkts.iterator();

			String str = " ";

			while(iter.hasNext()) {

				RtcpPkt aPkt = iter.next();

				str += (aPkt.getClass().toString() + ":"+aPkt.itemCount+ ", ");

			}

			System.out.println("<-> RTCPSenderThread.SendCompRtcpPkt() unicast to " + receiver + str);

		}

		try {

			rtcpSession.rtcpSock.send(packet);

			//Debug

			if(this.rtpSession.debugAppIntf != null) {

				this.rtpSession.debugAppIntf.packetSent(2, (InetSocketAddress) packet.getSocketAddress(), 

						new String("Sent unicast RTCP packet of size " + packet.getLength() + 

								" to " + packet.getSocketAddress().toString() + " via " 

								+ this.rtcpSession.rtcpSock.getLocalSocketAddress().toString()));

			}

		} catch (Exception e) {

			System.out.println("RTCPSenderThread.SendCompRtcpPkt() unicast failed.");

			e.printStackTrace();

			return -1;

		}

		return packet.getLength();

	}

	/**

	 * Check whether we can send an immediate feedback packet to this person

	 * @param ssrc SSRC of participant

	 */

	protected void reconsiderTiming(long ssrc) {

		Participant part =  this.rtpSession.partDb.getParticipant(ssrc);

		if( part != null && this.rtcpSession.fbSendImmediately()) {

			CompRtcpPkt compPkt = preparePacket(part, false);

			/*********** Send the packet ***********/

			// Keep track of sent packet length for average;

			int datagramLength;

			if(rtpSession.mcSession) {

				datagramLength = this.mcSendCompRtcpPkt(compPkt);

			} else {

				//part.debugPrint();

				datagramLength = this.sendCompRtcpPkt(compPkt, part.rtcpAddress);

			}

			/*********** Administrative tasks ***********/			

			//Update average packet size

			if(datagramLength > 0) {

				rtcpSession.updateAvgPacket(datagramLength);

			}

		} else if(part != null 

				&& this.rtcpSession.fbAllowEarly 

				&& this.rtcpSession.fbSendEarly()) {

			// Make sure we dont do it too often

			this.rtcpSession.fbAllowEarly = false;

			CompRtcpPkt compPkt = preparePacket(part, true);

			/*********** Send the packet ***********/

			// Keep track of sent packet length for average;

			int datagramLength;

			if(rtpSession.mcSession) {

				datagramLength = this.mcSendCompRtcpPkt(compPkt);

			} else {

				//part.debugPrint();

				datagramLength = this.sendCompRtcpPkt(compPkt, part.rtcpAddress);

			}

			/*********** Administrative tasks ***********/			

			//Update average packet size

			if(datagramLength > 0) {

				rtcpSession.updateAvgPacket(datagramLength);

			}

			rtcpSession.calculateDelay();

		}

		//Out of luck, fb message will have to go with next regular packet

		//Sleep for the remaining time.

		this.rtcpSession.nextDelay -= System.currentTimeMillis() - this.rtcpSession.prevTime;

		if(this.rtcpSession.nextDelay < 0)

			this.rtcpSession.nextDelay = 0;

	}

	/** 

	 * Prepare a packet. The output depends on the participant and how the

	 * packet is scheduled.

	 * 

	 * @param part the participant to report to

	 * @param regular whether this is a regularly, or early scheduled RTCP packet

	 * @return compound RTCP packet

	 */

	protected CompRtcpPkt preparePacket(Participant part, boolean regular) {

		/*********** Figure out what we are going to send ***********/

		// Check whether this person has sent RTP packets since the last RR.

		boolean incRR = false;

		if(part.secondLastRtcpRRPkt > part.lastRtcpRRPkt) {

			incRR = true;

			part.secondLastRtcpRRPkt = part.lastRtcpRRPkt;

			part.lastRtcpRRPkt = System.currentTimeMillis();

		}

		// Are we sending packets? -> add SR

		boolean incSR = false;

		if(rtpSession.sentPktCount > 0 && regular) {

			incSR = true;

		}

		/*********** Actually create the packet ***********/

		// Create compound packet

		CompRtcpPkt compPkt = new CompRtcpPkt();

		//If we're sending packets we'll use a SR for header

		if(incSR) {

			RtcpPktSR srPkt = new RtcpPktSR(this.rtpSession.ssrc, 

					this.rtpSession.sentPktCount, this.rtpSession.sentOctetCount, null);

			compPkt.addPacket(srPkt);

			if(part.ssrc > 0) {

				RtcpPkt[] ar = this.rtcpSession.getFromFbQueue(part.ssrc);

				if(ar != null) {

					for(int i=0; i<ar.length; i++) {

						compPkt.addPacket(ar[i]);

					}

				}

			}

		}

		//If we got anything from this participant since we sent the 2nd to last RtcpPkt

		if(incRR || !incSR) {

			Participant[] partArray = {part};

			if(part.receivedPkts < 1)

				partArray = null;

			RtcpPktRR rrPkt = new RtcpPktRR(partArray, rtpSession.ssrc);

			compPkt.addPacket(rrPkt);

			if( !incSR && part.ssrc > 0) {

				RtcpPkt[] ar = this.rtcpSession.getFromFbQueue(part.ssrc);

				if(ar != null) {

					for(int i=0; i<ar.length; i++) {

						compPkt.addPacket(ar[i]);

					}

				}

			}

		}

		// APP packets

		if(regular && part.ssrc > 0) {

			RtcpPkt[] ar = this.rtcpSession.getFromAppQueue(part.ssrc);

			if(ar != null) {

				for(int i=0; i<ar.length; i++) {

					compPkt.addPacket(ar[i]);

				}

			} else {

				//Nope

			}

		}

		// For now we'll stick the SDES on every time, and only for us

		//if(regular) {

			RtcpPktSDES sdesPkt = new RtcpPktSDES(true, this.rtpSession, null);

			compPkt.addPacket(sdesPkt);

		//}

		return compPkt;

	}

	/**

	 * Start the RTCP sender thread.

	 * 

	 * RFC 4585 is more complicated, but in general it will

	 * 1) Wait a precalculated amount of time

	 * 2) Determine the next RTCP recipient

	 * 3) Construct a compound packet with all the relevant information

	 * 4) Send the packet

	 * 5) Calculate next delay before going to sleep

	 */

	public void run() {

		if(RTPSession.rtcpDebugLevel > 1) {

			System.out.println("<-> RTCPSenderThread running");

		}

		// Give the application a chance to register some participants

		try { Thread.sleep(10); } 

		catch (Exception e) { System.out.println("RTCPSenderThread didn't get any initial rest."); }

		// Set up an iterator for the member list

		Enumeration<Participant> enu = null;

		Iterator<Participant> iter = null;

		// TODO Change to rtcpReceivers

		if(rtpSession.mcSession) {

			enu = rtpSession.partDb.getParticipants();

		} else {

			iter = rtpSession.partDb.getUnicastReceivers();

		}

		while(! rtpSession.endSession) {

			if(RTPSession.rtcpDebugLevel > 5) {

				System.out.println("<-> RTCPSenderThread sleeping for " +rtcpSession.nextDelay+" ms");

			}

			try { Thread.sleep(rtcpSession.nextDelay); } 

			catch (Exception e) { 

				System.out.println("RTCPSenderThread Exception message:" + e.getMessage());

				// Is the party over?

				if(this.rtpSession.endSession) {

					continue;

				}

				if(rtcpSession.fbWaiting != -1) {

					reconsiderTiming(rtcpSession.fbWaiting);

					continue;

				}

			}

			/** Came here the regular way */

			this.rtcpSession.fbAllowEarly = true;

			if(RTPSession.rtcpDebugLevel > 5) {

				System.out.println("<-> RTCPSenderThread waking up");

			}

			// Regenerate nextDelay, before anything happens.

			rtcpSession.calculateDelay();

			// We'll wait here until a conflict (if any) has been resolved,

			// so that the bye packets for our current SSRC can be sent.

			if(rtpSession.conflict) {

				if(! this.byesSent) {

					sendByes();

					this.byesSent = true;

				}

				continue;

			}

			this.byesSent = false;

			//Grab the next person

			Participant part = null;

			//Multicast

			if(this.rtpSession.mcSession) {

				if(! enu.hasMoreElements())

					enu = rtpSession.partDb.getParticipants();

				if( enu.hasMoreElements() ) {

					part = enu.nextElement();

				} else {

					continue;

				}

			//Unicast

			} else {

				if(! iter.hasNext()) {

					iter = rtpSession.partDb.getUnicastReceivers();

				}

				if(iter.hasNext() ) {

					while( iter.hasNext() && (part == null || part.rtcpAddress == null)) {

						part = iter.next();

					}

				}

				if(part == null || part.rtcpAddress == null)

					continue;

			}

			CompRtcpPkt compPkt = preparePacket(part, true);

			/*********** Send the packet ***********/

			// Keep track of sent packet length for average;

			int datagramLength;

			if(rtpSession.mcSession) {

				datagramLength = this.mcSendCompRtcpPkt(compPkt);

			} else {

				//part.debugPrint();

				datagramLength = this.sendCompRtcpPkt(compPkt, part.rtcpAddress);

			}

			/*********** Administrative tasks ***********/			

			//Update average packet size

			if(datagramLength > 0) {

				rtcpSession.updateAvgPacket(datagramLength);

			}

		}

		// Be polite, say Bye to everone

		sendByes();

		try { Thread.sleep(200);} catch(Exception e) {}

		if(RTPSession.rtcpDebugLevel > 0) {

			System.out.println("<-> RTCPSenderThread terminating");

		}

	}

}