import java.io.InputStream;
import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.lang.String;
import java.util.Enumeration;
import javax.swing.JList;
import net.jxta.document.Advertisement;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.MimeMediaType;
import net.jxta.discovery.DiscoveryService;
import net.jxta.discovery.DiscoveryListener;
import net.jxta.discovery.DiscoveryEvent;
import net.jxta.exception.PeerGroupException;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupFactory;
import net.jxta.protocol.DiscoveryResponseMsg;
import net.jxta.protocol.PeerAdvertisement;


/*
*PeerDiscovery
*Responsible for local and remote discovery of peers.
*Also responsible for updating the peer info in the GUI.
*/
public class PeerDiscovery implements Runnable, DiscoveryListener {
    //necessary links to important local peer information
    private PeerGroup netPeerGroup;
    private DiscoveryService discovery;
    private PeerAdvertisement peerAdv;

    //link to peer GUI list
    private JList peerList;
    private String defaultPeerName;

    //link to GUI discovery selection type (local or remote)
    private boolean local;

    /*
    *Update peer GUI for adding/removing peers
    */
    private void updateGUI(boolean stringCast, Enumeration enum) {
        String str = null;
        PeerAdvertisement newAdv = null;
        MimeMediaType mmt = new MimeMediaType("text/xml");
        SortedListModel peers = (SortedListModel) peerList.getModel();

        while (enum.hasMoreElements()) {
            //Processing String objects
            if (stringCast) {
                str = (String) enum.nextElement();

                try {
                    //create an advertisement for each element
                    newAdv = (PeerAdvertisement) AdvertisementFactory.newAdvertisement(
                                     mmt, 
                                     new ByteArrayInputStream(str.getBytes()));
                } catch (IOException ioe) {
                    System.out.println("Error parsing response element!");
                    ioe.printStackTrace();

                    continue;
                }
            }
            //Processing PeerAdvertisement objects
            else {
                newAdv = (PeerAdvertisement) enum.nextElement();
            }

            System.out.println("Discovered peer =" + newAdv.getName());

            //found a new peer,add them to the peerList
            if (peers.contains(newAdv.getName()) == false) {
                peers.addElement(newAdv.getName());
                System.out.println("Discovered peer = " + newAdv.getName() + 
                                   " added");
            }
        }


        //update the GUI
        peerList.setModel(peers);
        peerList.setSelectedValue(defaultPeerName, true);
    }

    /*
    *Start JXTA method
    */
    public void startJxta() {
        //flush local JXTA cache
        flushPeerInfo();
    }

    /*
    *Flush local peer cache information
    */
    public void flushPeerInfo() {
        try {
            discovery.flushAdvertisements(null, DiscoveryService.PEER);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
    *On demand,discover peers locally or remotely
    *via a thread.
    */
    public void run() {
        Enumeration enum = null;
        SortedListModel peers = (SortedListModel) peerList.getModel();

        try {
            //Add ourselves as a discoverylistener for
            //discovery response events.
            discovery.addDiscoveryListener(this);

            //check local cache for peer
            if (local) {
                enum = discovery.getLocalAdvertisements(DiscoveryService.PEER, 
                                                        null, null);

                if ((enum == null) || (enum.hasMoreElements() == false)) {
                    System.out.println("No local advertisements found");
                }

                System.out.println("update GUI peer discovery now");


                //Update peer list in GUI
                updateGUI(false, enum);
            }
            //Wait 10 seconds per remote discovery
            else {
                discovery.getRemoteAdvertisements(null, DiscoveryService.PEER, 
                                                  null, null, 10, this);

                try {
                    Thread.sleep(10 * 1000);
                } catch (Exception e) {
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
    *Handle remote discovery messages.
    */
    public void discoveryEvent(DiscoveryEvent e) {
        DiscoveryResponseMsg drm = e.getResponse();
        String response = drm.getPeerAdv();
        InputStream is = null;
        PeerAdvertisement peerAdv = null;
        MimeMediaType mmt = new MimeMediaType("text/xml");

        try {
            //create a peer advertisement
            is = new ByteArrayInputStream(response.getBytes());
            peerAdv = (PeerAdvertisement) AdvertisementFactory.newAdvertisement(
                              mmt, is);
            System.out.println("[ Received discovery response [" + 
                               drm.getResponseCount() + 
                               " elements ] from peer ::" + 
                               peerAdv.getName() + " ]");
        } catch (IOException ioe) {
            System.out.println("Error parsing remote peer抯 advertisement!");
            ioe.printStackTrace();

            return;
        }


        //update peers in GUI
        updateGUI(true, drm.getResponses());
    }

    /*
    *set discovery to be local or remote
    *local = true ->search is local
    *local = false ->search is remote
    */
    public void setLocalDiscovery(boolean local) {
        this.local = local;
    }

    /*
    *Creates new PeerDiscovery object.
    */
    public PeerDiscovery(PeerGroup netPeerGroup, DiscoveryService discovery, 
                         JList peerList, String defaultPeerName) {
        this.netPeerGroup = netPeerGroup;
        this.discovery = discovery;
        this.peerList = peerList;
        this.defaultPeerName = defaultPeerName;
        local = true;
    }
}