package org.pdtp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class UDPServer {

    public byte[][] storage;
    public long[] keys;

    public static void main(String[] args) {
        UDPServer server = new UDPServer();
        server.init();
    }

    public void init() {
        storage = new byte[0x10000][1024 * 1024 * 2];
        keys = new long[0x10000];

        Thread serverThread = new Thread(new Server());
        serverThread.start();
    }

    public class Server implements Runnable {

        public void run() {
            DatagramSocket socket = null;

            try {
                socket = new DatagramSocket(7777);
            } catch (SocketException ex) {
            }

            ExecutorService pool = Executors.newFixedThreadPool(32);

            while (true) {
                DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

                try {
                    socket.receive(packet);
                } catch (IOException ex) {
                }

                pool.execute(new Responder(socket, packet));
            }
        }
    }

    public class Responder implements Runnable {

        DatagramSocket socket = null;
        DatagramPacket packet = null;

        public Responder(DatagramSocket socket, DatagramPacket packet) {
            this.socket = socket;
            this.packet = packet;
        }

        public void run() {
            byte[] pData = packet.getData();
            short address = 0;
            long passkey = 0;
            byte[] data = new byte[] { 0 };

            if (pData.length >= 3) {
                address = (short) (pData[1] << 8 | pData[2]);

                switch (pData[0]) {
                case 0: /* Read Packet - Requests target (16b) and key (64b) */
                    if (pData.length >= 11) {
                        passkey = (long) (pData[10] << 56 | pData[9] << 48
                                | pData[8] << 40 | pData[7] << 32
                                | pData[6] << 24 | pData[5] << 16
                                | pData[4] << 8 | pData[3]);
                        if (keys[address] == passkey) {
                            data = storage[address];
                        }
                    }
                    break;
                case 1: /*
                         * Write Packet - Requests target (16b) and data
                         * (<=1024b * 1024b * 2b)
                         */
                    if (pData.length >= 4) {
                        if (storage[address] == null) {
                            System.arraycopy(pData, 3, storage[address],
                                    0, pData.length - 3);
                            data = new byte[] { 1 };
                        }
                    }
                    break;
                case 2: /* Kill Packet - Requests target (16b) and key (64b) */
                    if (pData.length >= 11) {
                        passkey = (long) (pData[10] << 56 | pData[9] << 48
                                | pData[8] << 40 | pData[7] << 32
                                | pData[6] << 24 | pData[5] << 16
                                | pData[4] << 8 | pData[3]);
                        if (keys[address] == passkey) {
                            storage[address] = null;
                            data = new byte[] { 1 };
                        }
                        break;
                    }
                }

                DatagramPacket response = new DatagramPacket(data, data.length,
                        packet.getAddress(), packet.getPort());

                try {
                    socket.send(response);
                } catch (IOException ex) {
                }
            }
        }
    }
}