source: trunk/src/org/expeditee/network/FrameShare.java@ 305

package org.expeditee.network;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;

import org.expeditee.gui.AttributeValuePair;
import org.expeditee.gui.Frame;
import org.expeditee.gui.MessageBay;
import org.expeditee.io.ExpReader;
import org.expeditee.io.FrameReader;
import org.expeditee.items.Text;

public class FrameShare {

        private static FrameShare _theSession = null;

        private static FrameServer _server = null;

        private Map<String, Peer> _peers;

        public static void init(Frame settingsFrame) {
                if (settingsFrame == null)
                        return;

                if (_theSession == null)
                        _theSession = new FrameShare(settingsFrame);
        }

        private FrameShare(Frame settingsFrame) {
                _peers = new HashMap<String, Peer>();

                // Set the settings
                for (Text item : settingsFrame.getBodyTextItems(false)) {

                        AttributeValuePair avp = new AttributeValuePair(item.getText());
                        if (avp.isAnnotation())
                                continue;

                        String attribute = avp.getAttributeOrValue().toLowerCase();

                        if (attribute.equals("server")) {
                                try {
                                        if (!avp.hasPair()) {
                                                _server = new FrameServer();
                                        } else {
                                                _server = new FrameServer("FrameServer", avp
                                                                .getIntegerValue());
                                        }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                        MessageBay.errorMessage("Could not start frame server ["
                                                        + avp.toString() + "]");
                                }
                                continue;
                        }

                        if (!avp.hasPair())
                                continue;

                        try {
                                _peers.put(attribute, new Peer(avp));
                        } catch (UnknownHostException e) {
                                MessageBay.errorMessage("Could not locate peer ["
                                                + avp.toString() + "]");
                        }
                }

                try {
                        if (_server != null) {
                                _server.start();
                        }
                } catch (Exception e) {
                        MessageBay.errorMessage("Error in PeerToPeer setup");
                }
        }

        public void finalise() {
                _server.close();
        }

        public static FrameShare getInstance() {
                return _theSession;
        }

        /**
         * TODO check each peer on a different thread.
         * 
         * @param frameName
         * @return
         */
        public Frame loadFrame(String frameName) {
                byte[] nameBuf = frameName.getBytes();
                byte[] buf = new byte[2056];

                String result = null;
                String peerName = null;
                try {
                        // get a datagram socket
                        DatagramSocket socket = new DatagramSocket();
                        socket.setSoTimeout(1000);

                        for (Peer peer : _peers.values()) {
                                try {
                                        // send request for a frame
                                        DatagramPacket packet = new DatagramPacket(nameBuf,
                                                        nameBuf.length, peer.getAddress(), peer.getPort());
                                        socket.send(packet);

                                        // get response
                                        packet = new DatagramPacket(buf, buf.length);
                                        socket.receive(packet);

                                        // store frame contents
                                        result = new String(packet.getData(), 0, packet.getLength());
                                        peerName = peer.getName();
                                        break;
                                } catch (Exception e) {
                                        e.printStackTrace();
                                }
                        }
                        socket.close();
                } catch (Exception e) {

                }
                
                if(result == null)
                        return null;
                
                // Now read the frame from the file contents
                FrameReader reader = new ExpReader(frameName);
                Frame frame = null;
                try {
                        frame = reader.readFrame(new BufferedReader(
                                        new StringReader(result)));
                        // Set the path for the frame to indicate it is NOT a local frame
                        // This allows the frame to be saved in the correct location
                        frame.setLocal(false);
                        frame.setPath(peerName);
                } catch (IOException e) {
                        e.printStackTrace();
                }

                if (frame == null) {
                        MessageBay.errorMessage("Error: " + frameName
                                        + " could not be successfully loaded.");
                        return null;
                }

                return frame;
        }
}