package org.hwmhere.udp.receive;

import java.io.*;
import java.net.*;

import org.hwmhere.udp.UDPConstant;
import org.hwmhere.util.math.BaseType;

public class RUDPReceiver {

	private int port;

	private InetAddress sender;

	private byte[] receiveData;// = new byte[UDPConstant.DATA_SIZE];

	private int dataLength = 0;

	private byte[] tempReceiveData = new byte[UDPConstant.DATA_SEGMENT_LENGTH];

	private byte[] echoData;// = new byte[UDPConstant.ECHO_LENGTH];

	private DatagramSocket serverSocket;

	private DatagramPacket receivePacket;

	private DatagramPacket sendPacket;

	/**
	 * 用于發送報文序號的計數 如果初始為0,在RDT2.0中只加不減 只有當一個數據報成功接收并返回ACK后才加一
	 * 
	 * @see #upSequence()
	 * @see #downSequence()
	 */
	private int sequence = 0;

	public RUDPReceiver(int port) throws SocketException {

		this.port = port;

		serverSocket = new DatagramSocket(port);

		receivePacket = new DatagramPacket(tempReceiveData,
				tempReceiveData.length);

	}

	public void close() {
		serverSocket.close();
	}

	public void reveive() {

		try {
			boolean isLast = false;
			while (!isLast) {
				// INFORMation
				System.out.println("Receive Datagram " + sequence);
				serverSocket.receive(receivePacket);
				// UPD R 處理
				// TODO:注意,這里只能保證一個用戶連接,否則會出錯,產生數據交叉
				InetAddress tempSender = receivePacket.getAddress();
				int tempPort = receivePacket.getPort();
				if (0 == sequence) {
					sender = tempSender;
					port = tempPort;
				}
				if (!legalSource(tempSender, port)) {
					continue;
				}
				if (isReliable(receivePacket)) {
					// 保存受到的信息
					this.setReceiveData(receivePacket);
					echoData = UDPConstant.ACK.getBytes();
					sendPacket = new DatagramPacket(echoData, echoData.length,
							tempSender, port);
					serverSocket.send(sendPacket);
					upSequence();
					// 最后一個數據報文的回復，結束
					// 這里也正確接受了,能夠保證數據有效
					// 故可以關閉socket,如果發送者不能夠正確接受到ACK,可以采取再發或者直接關閉
					if (isTheLast(receivePacket)) {
						isLast = true;
						System.out.println("文件接收完畢!");
						this.close();
					}
				} else {
					echoData = UDPConstant.NAK.getBytes();
					sendPacket = new DatagramPacket(echoData, echoData.length,
							tempSender, port);
					serverSocket.send(sendPacket);
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private boolean legalSource(InetAddress sender, int port) {
		if (this.sender == sender && this.port == port)
			return true;
		return false;
	}

	// 判斷是否可靠
	// TODO:
	private int returnSequence(DatagramPacket packet) {

		byte[] tempSequence = new byte[4];

		tempSequence[0] = packet.getData()[0];
		tempSequence[1] = packet.getData()[1];
		tempSequence[2] = tempSequence[3] = (byte) 0;

		return BaseType.lBytesToInt(tempSequence);

	}

	boolean isReliable(DatagramPacket packet) {

		int tempSequence = returnSequence(packet);

		if (tempSequence != sequence) {
			return false;
		}

		// if

		return true;
	}

	// 判斷是否是最后一個包
	// TODO:1.0
	boolean isTheLast(DatagramPacket packet) {

		int tempFlage = (int) packet.getData()[2];

		if (tempFlage == 1) {
			return true;
		}
		return false;
	}

	public void setReceiveData(DatagramPacket packet) throws IOException {

		byte[] tempData = packet.getData();

		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		if (receiveData != null) {
			bos.write(receiveData);
		}

		System.out
				.println("tempReceiveData 長度:" + (packet.getLength() - 3));

		//TODO:OFFSET
		bos.write(tempData,packet.getOffset()+3,packet.getLength()-3);

		receiveData = bos.toByteArray();

	}

	public static void main(String args[]) throws Exception {

		while (true) {

			RUDPReceiver receiver = new RUDPReceiver(6790);

			receiver.reveive();

			byte[] receivedData = receiver.getReceiveData();

			String string = new String(receivedData);

			System.out.println(string);
			System.out.println("接收到數據長度:" + receivedData.length);

		}

	}

	public byte[] getReceiveData() {
		return receiveData;
	}

	public byte[] getechoData() {
		return echoData;
	}

	public void setechoData(byte[] echoData) {
		this.echoData = echoData;
	}

	public int getPort() {
		return port;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public DatagramPacket getReceivePacket() {
		return receivePacket;
	}

	private void upSequence() {
		sequence++;
	}

	private void downSequence() {
		sequence--;
	}

	public InetAddress getSender() {
		return sender;
	}

	public void setSender(InetAddress sender) {
		this.sender = sender;
	}

	public int getDataLength() {
		return dataLength;
	}

	public void setDataLength(int dataLength) {
		this.dataLength = dataLength;
	}
}