import java.io.IOException;
import javax.net.DataLinkLayer;
import javax.net.ReadFromLowerLayerTimeoutException;

public class SimpleDataLinkLayer extends DataLinkLayer {

	/**
	 * Zeit in ms in der ein gesendetes Paket bestätigt sein muss
	 */
	private static final int ACK_TIMEOUT = 300;

	/**
	 * Druchschnittliche Transferzeit (wird beim Sender gemessen) mit Hilfe eines 
	 * MovingAverage
	 */
	private MovingAverage transmitTime = new MovingAverage(20);

	/**
	 * Gesamtzahl aller Frames die beim Empfänger ankommen (inklusive nicht angekommen)
	 */
	private int receiverTotalFrames = 0;
	/**
	 * Gesamtzahl aller Frames die beim Empfänger nicht ankommen (wird mit Hilfe des 
	 * Resent-Couters gezählt)
	 */
	private int receiverLostFrames = 0;
	/**
	 * Gesamtzahl aller defekten Frames
	 */
	private int receiverDamagedFrames = 0;
	/**
	 * Sequenznummer die das nächste zu sendende Paket bekommt
	 */
	private int sequence = 0;
	/**
	 * Sequenznummer des zuletzt empfangen Paketes
	 */
	private int lastSequenceReceived = Integer.MIN_VALUE;


	public void send()  {

		boolean continueSend = true;

		while(continueSend) {

			try {
				// auf Daten von der höheren Schicht warten
				byte from_upper[] = new byte[Packet.MAX_FRAME_LEN];
				int len = readFromUpperLayer(from_upper, Packet.MAX_FRAME_LEN);
				Packet dataPacket = Packet.withPayload(from_upper, len);

				// Header setzen & Checksumme berechnen	
				dataPacket.setSequence(this.sequence);
				dataPacket.setResentCounter(0);
				dataPacket.makeCRC();

				setReadFromLowerLayerTimeout(ACK_TIMEOUT);

				boolean packet_send = false;
				do {
					// daten senden
					byte[] data = dataPacket.getBytes();
					writeToLowerLayer(data, data.length);
					// notieren des Sendenzeitpunkt des Datenpaketes und zählen des Pakets
					long sendTime = System.currentTimeMillis(); 

					try {
						// auf Bestätigungspaket warten
						byte ack[] = new byte[Packet.MAX_FRAME_LEN];
						int len_ack = readFromLowerLayer(ack, Packet.MAX_FRAME_LEN);
						Packet ack_packet = Packet.fromRawData(ack, len_ack);

						// empfangenes Paket prüfen
						if(!ack_packet.isCRCokay()) continue;
						if(!ack_packet.isAckPacket()) continue;
						if(ack_packet.getSequence() != this.sequence) continue;

						// die Transferzeit ist (näherungsweise) die halbe roundtripzeit
						long transferTime = (System.currentTimeMillis() - sendTime) / 2;
						// die durchschnittliche Transferzeit updaten
						this.transmitTime.update(transferTime);

						//System.out.printf("\nsend(): Packet %d:%d sent\n", this.sequence, dataPacket.getResentCounter());

						packet_send = true;	// das Paket wurde erfolgreich gesendet

					} catch (ReadFromLowerLayerTimeoutException e) {
						/*
						 * es wurde keine Bestätigungspaket innerhalb der gesetzten Zeit 
						 * erhalten der resentcounter des Pakets wird erhöht und es wird 
						 * beim nächsten schleifen durchlauf neu gesendet
						 */
						//System.out.printf("\nsend(): Packet %d:%d failed\n", this.sequence, dataPacket.getResentCounter());
						dataPacket.setResentCounter(dataPacket.getResentCounter()+1);
						dataPacket.makeCRC();
					}
				} while(!packet_send);
				// das Paket wurde erfolgreich gesendet und bestätigt
				this.sequence++;

			} catch( IOException e) {
				continueSend = false;
				System.err.println("IOException in send()");
				e.printStackTrace();
			}
			System.out.printf(
					"Avg. Transfertime  : %5.2f ms\n", this.transmitTime.getAverage());
		}
	}



	public void receive() {

		boolean continueReceive = true;	

		while (continueReceive) {
			// es wird unendlich lange auf daten gewartet
			setReadFromLowerLayerTimeout(0);

			try {
				// daten aus der daruterliegenden Schicht lesen
				byte from_lower[] = new byte[Packet.MAX_FRAME_LEN];
				int len = readFromLowerLayer(from_lower, Packet.MAX_FRAME_LEN);
				Packet receivedPacket = Packet.fromRawData(from_lower, len);

				this.receiverTotalFrames++;
				// CRC prüfen. Wenn das Paket defekt ist, wird es gezählt
				if(!receivedPacket.isCRCokay()) {
					this.receiverDamagedFrames++;
					//System.out.printf("receive(): Packet %d:%d damaged\n", receivedPacket.getSequence(), receivedPacket.getResentCounter());
					continue;
				}
				if(receivedPacket.getSequence() == this.lastSequenceReceived) {
					/*
					 * auch wenn das Paket ein Dublikat ist, müssen wir es nochmal 
					 * bestätigen, sonst bekommen wir es immer wieder
					 */
					//System.out.printf("\nreceive(): Packet %d:%d dublicate\n", receivedPacket.getSequence(), receivedPacket.getResentCounter());
					sendAck(receivedPacket);
					continue;
				}
				else if(receivedPacket.getSequence() < this.lastSequenceReceived) {
					System.out.printf("\nreceive(): Packet %d:%d IN WRONG ORDER. Previous SequNr was %d\n", 
							receivedPacket.getSequence(), receivedPacket.getResentCounter(), lastSequenceReceived);
					continueReceive = false;
					break;
				}
				else if(receivedPacket.getResentCounter() > 0) {
					/*
					 * wenn der resentcounter im empfangenen Paket größer als 0 ist, wurde
					 * es so oft gesendet wie der resentCounter anzeigt
					 */
					this.receiverLostFrames += receivedPacket.getResentCounter();
					this.receiverTotalFrames += receivedPacket.getResentCounter();
				}


				/*
				 * Datenpakete werden an die höhere Schicht gegeben, bestätigt und die 
				 * Sequenznummer wird als empfangen markiert
				 */
				if(receivedPacket.isDataPacket()) {
					byte[] data = receivedPacket.getPayload();
					writeToUpperLayer(data, data.length);
					//System.out.printf("\nreceive(): Packet %d:%d received\n", receivedPacket.getSequence(), receivedPacket.getResentCounter());

					sendAck(receivedPacket);
					this.lastSequenceReceived = receivedPacket.getSequence();
				}

			} 
			catch (ReadFromLowerLayerTimeoutException e) {
				// das kannn nicht eintreten 
			} 
			catch (IOException e) {
				continueReceive = false;
				System.err.println("IOException in receive()");
				e.printStackTrace();
			}

			if(receiverTotalFrames > 0) {
				// zahl der tatsächlich erhaltenen pakete (abzüglich verlorener)
				
				int totalReceived = receiverTotalFrames - receiverLostFrames;
				System.out.printf("Receiver lost Frames    : %5.2f%% (%d of %d)\n",
						receiverLostFrames*100.0/receiverTotalFrames, 
						receiverLostFrames, receiverTotalFrames);
				System.out.printf("Receiver damaged Frames : %5.2f%% (%d of %d)\n",
						receiverDamagedFrames*100.0/totalReceived,
						receiverDamagedFrames, totalReceived);
			}

		}
	}

	/**
	 * sendet ein Bestätigungspaket für ein gegebenes Paket
	 * @param toAck das Paket für das die Bestätigung gesendet werden soll
	 * @throws IOException wenn Fehler beim schreiben auf den unteren Schicht auftritt
	 */
	private void sendAck(Packet toAck) throws IOException {
		Packet ack_packet = toAck.createACK();
		ack_packet.makeCRC();
		writeToLowerLayer(ack_packet.getBytes(), ack_packet.getBytes().length);
	}

}