package com.cn.darkblue.helper;

import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.cn.darkblue.listener.BaseCommListener;
import com.cn.darkblue.listener.GroupBaseCommListener;
import com.cn.darkblue.util.CFDefData;
import com.cn.darkblue.util.CFResource;
import com.cn.darkblue.util.CFUtil;

import net.jxta.credential.AuthenticationCredential;
import net.jxta.document.Element;
import net.jxta.discovery.DiscoveryService;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.Document;
import net.jxta.document.MimeMediaType;
import net.jxta.document.StructuredDocument;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.StructuredTextDocument;
import net.jxta.document.TextElement;
import net.jxta.document.XMLDocument;
import net.jxta.exception.PeerGroupException;
import net.jxta.id.ID;
import net.jxta.id.IDFactory;
import net.jxta.impl.endpoint.mcast.McastTransport;
import net.jxta.impl.id.UUID.ModuleSpecID;
import net.jxta.impl.loader.RefJxtaLoader;
import net.jxta.impl.membership.passwd.PasswdMembershipService;
import net.jxta.impl.peergroup.StdPeerGroupParamAdv;
import net.jxta.membership.Authenticator;
import net.jxta.membership.MembershipService;
import net.jxta.peergroup.NetPeerGroupFactory;
import net.jxta.peergroup.PeerGroup;
import net.jxta.peergroup.PeerGroupID;
import net.jxta.pipe.InputPipe;
import net.jxta.pipe.OutputPipe;
import net.jxta.pipe.PipeID;
import net.jxta.pipe.PipeService;
import net.jxta.platform.ModuleClassID;
import net.jxta.platform.NetworkConfigurator;
import net.jxta.protocol.ModuleImplAdvertisement;
import net.jxta.protocol.PeerAdvertisement;
import net.jxta.protocol.PeerGroupAdvertisement;
import net.jxta.protocol.PipeAdvertisement;

public class GroupHelper {
	private static final Log log = LogFactory.getLog(GroupHelper.class);
    public static final String PIPE_ID_STR = "BASE_PIPE_ID";
    public static final String PIPE_NAME_STR = "BASE_PIPE_NAME";
    public static final String PIPE_TYPE_STR = "BASE_PIPE_TYPE";
    
    public static final String PIPE_IN_KEY = "BASE_IN_KEY";
    public static final String PIPE_OUT_KEY = "BASE_OUT_KEY";
    /*
    public static PeerGroup lunchNewPeerGroup(PeerGroup wpg,PeerGroupID domainID, String domainName) throws PeerGroupException {
        assert wpg.getPeerGroupID().equals(PeerGroupID.worldPeerGroupID);

        ModuleImplAdvertisement npgImplAdv;
        try {
            npgImplAdv = wpg.getAllPurposePeerGroupImplAdvertisement();
            System.out.println("npgImplAdv \n"+npgImplAdv.getDocument(MimeMediaType.XMLUTF8));
            npgImplAdv.setModuleSpecID(PeerGroup.allPurposePeerGroupSpecID);

            StdPeerGroupParamAdv params = new StdPeerGroupParamAdv(npgImplAdv.getParam());

            params.addProto(McastTransport.MCAST_TRANSPORT_CLASSID, McastTransport.MCAST_TRANSPORT_SPECID);

            npgImplAdv.setParam((XMLDocument) params.getDocument(MimeMediaType.XMLUTF8));
            
           
           // npgImplAdv.putServiceParam(PeerGroup.pipeClassID,
		   // 		CreatBasePipe(domainID,domainName+CFDefData.COMBO_SPSTR+"PIPE",PipeService.PropagateType));
           
        } catch (Exception failed) {
            throw new PeerGroupException("Could not construct domain ModuleImplAdvertisement", failed);
        }

        // Configure the domain

        NetworkConfigurator domainConfig = NetworkConfigurator.newAdHocConfiguration(wpg.getStoreHome());
        //NetworkConfigurator.n

        //PeerGroupID domainID = tutorial.id.IDTutorial.createPeerGroupID(domainName);
        domainConfig.setInfrastructureID(domainID);
        domainConfig.setName(wpg.getPeerName());
        domainConfig.setPeerID(wpg.getPeerID());
        domainConfig.setUseMulticast(true);
        int domainMulticastPort = 1025 + (domainName.hashCode() % 60000);
        domainConfig.setMulticastPort(domainMulticastPort);

        // Instantiate the domain net peer group

        NetPeerGroupFactory npgf1 = new NetPeerGroupFactory(wpg, domainConfig.getPlatformConfig(), npgImplAdv);
        PeerGroup domain = npgf1.getInterface();
        System.out.println("Peer Group : " + domain + " started!");

        return domain;
    }*/
    
    
	// ??????
	public PeerGroup createPeerGroup(PeerGroup rootPeerGroup,
			PeerGroupID newPeerGroupID, String groupName, String login,
			String passwd,String description) {
		// create the Peer Group by doing the following:
		// - Create a Peer Group Module Implementation Advertisement and publish
		// it
		// - Create a Peer Group Adv and publish it
		// - Create a Peer Group from the Peer Group Adv and return this object
		PeerGroup satellaPeerGroup = null;
		PeerGroupAdvertisement satellaPeerGroupAdvertisement;
		// Create the PeerGroup Module Implementation Adv
		ModuleImplAdvertisement passwdMembershipModuleImplAdv;
		passwdMembershipModuleImplAdv = this
				.createPasswdMembershipPeerGroupModuleImplAdv(rootPeerGroup);
		// Publish it in the parent peer group
		DiscoveryService rootPeerGroupDiscoveryService = rootPeerGroup
				.getDiscoveryService();
		try {
			rootPeerGroupDiscoveryService.publish(
					passwdMembershipModuleImplAdv, PeerGroup.DEFAULT_LIFETIME,
					PeerGroup.DEFAULT_EXPIRATION);
			rootPeerGroupDiscoveryService
					.remotePublish(passwdMembershipModuleImplAdv,
							PeerGroup.DEFAULT_EXPIRATION);
		} catch (java.io.IOException e) {
			log.error("Can't Publish passwdMembershipModuleImplAdv");
		}
		
		//PeerAdvertisement pa = null;
		
		// Now, Create the Peer Group Advertisement
		satellaPeerGroupAdvertisement = this.createPeerGroupAdvertisement(
				//passwdMembershipModuleImplAdv, 
				
				newPeerGroupID, groupName,
				login, passwd,description);
		
		// Publish it in the parent peer group
		try {
			rootPeerGroupDiscoveryService.publish(
					satellaPeerGroupAdvertisement, PeerGroup.DEFAULT_LIFETIME,
					PeerGroup.DEFAULT_EXPIRATION);
			rootPeerGroupDiscoveryService.remotePublish(
					satellaPeerGroupAdvertisement,

					PeerGroup.DEFAULT_EXPIRATION);
		} catch (java.io.IOException e) {
			log.error("Can't Publish satellaPeerGroupAdvertisement");
		}
		// Finally Create the Peer Group
		if (satellaPeerGroupAdvertisement == null) {
			log.error("satellaPeerGroupAdvertisement is null");
		}
		try {
			//satellaPeerGroupAdvertisement.se
			satellaPeerGroup = rootPeerGroup
					.newGroup(satellaPeerGroupAdvertisement);
		} catch (net.jxta.exception.PeerGroupException e) {
			log.error("Can't create Satella Peer Group from Advertisement");
			return null;
		}
		
		IPGResource pgres = new PGResource();
		CFResource.getInstance().getJoinPGMap().put(satellaPeerGroup, pgres);
		
		initConPipe(satellaPeerGroup);//初始化基本通訊
		return satellaPeerGroup;
	}

	public PeerGroup createPeerGroup(PeerGroup rootPeerGroup, String groupName,
			String login, String passwd,String description) {

		PeerGroupID netPeerGroupId = IDFactory.newPeerGroupID();
		return createPeerGroup(rootPeerGroup, netPeerGroupId, groupName, login,
				passwd,description);
	}
	
	public PeerGroup createPeerGroup(PeerGroup rootPeerGroup,String id, String groupName,
           String login, String passwd ,String description){
		PeerGroupID pgId = PeerGroupID.create(URI.create(id));
		return createPeerGroup(rootPeerGroup, pgId, groupName, login,
				passwd,description);
		
	}

	// ????????
	private PeerGroupAdvertisement createPeerGroupAdvertisement(
			//ModuleImplAdvertisement passwdMembershipModuleImplAdv,
			PeerGroupID newPeerGroupID, String groupName, String login,
			String passwd,String description) {
		// Create a PeerGroupAdvertisement for the peer group
		PeerGroupAdvertisement satellaPeerGroupAdvertisement = (PeerGroupAdvertisement) AdvertisementFactory
				.newAdvertisement(PeerGroupAdvertisement.getAdvertisementType());
		
		
		// Instead of creating a new group ID each time, by using the
		// line below
		// satellaPeerGroupAdvertisement.setPeerGroupID
		// (IDFactory.newPeerGroupID());
		// I use a fixed ID so that each time I start PrivatePeerGroup,
		// it creates the same Group
		satellaPeerGroupAdvertisement.setPeerGroupID(newPeerGroupID);
		
//		satellaPeerGroupAdvertisement
//				.setModuleSpecID(passwdMembershipModuleImplAdv
//						.getModuleSpecID());
		
		satellaPeerGroupAdvertisement
		.setModuleSpecID(PeerGroup.allPurposePeerGroupSpecID);
		
		satellaPeerGroupAdvertisement.setName(groupName);
		satellaPeerGroupAdvertisement
				.setDescription(description);
		// Now create the Structured Document Containing the login and
		// passwd informations. Login and passwd are put into the Param
		// section of the peer Group
		if (login != null) {
			
			StructuredTextDocument loginAndPasswd = (StructuredTextDocument) StructuredDocumentFactory
					.newStructuredDocument(new MimeMediaType("text/xml"),
							"Parm");
			String loginAndPasswdString = login + ":"
					+ PasswdMembershipService.makePsswd(passwd) + ":";
			TextElement loginElement = loginAndPasswd.createElement("login",
					loginAndPasswdString);
			loginAndPasswd.appendChild(loginElement);
			
			// All Right, now that loginAndPasswdElement
			// (The strucuted document
			// that is the Param Element for The PeerGroup Adv
			// is done, include it in the Peer Group Advertisement
			
			satellaPeerGroupAdvertisement.putServiceParam(
					PeerGroup.membershipClassID, loginAndPasswd);
			
		    satellaPeerGroupAdvertisement.putServiceParam(PeerGroup.pipeClassID,
		    		CreatBasePipe(newPeerGroupID,groupName+CFDefData.COMBO_SPSTR+"PIPE",PipeService.PropagateType));
		}
		return satellaPeerGroupAdvertisement;
	}
	//加進(jìn)基礎(chǔ)的通信廣告
	private Element CreatBasePipe(PeerGroupID pgId,String name,String type){

	    StructuredTextDocument basePipe = (StructuredTextDocument) StructuredDocumentFactory
		.newStructuredDocument(new MimeMediaType("text/xml"),
				"Parm");
	    
	    PipeID pipeID = null;

        try {
            pipeID = (PipeID) IDFactory.newPipeID(pgId);
        } catch (Exception use) {
            use.printStackTrace();
        }
        
	    TextElement IdElement = basePipe.createElement(PIPE_ID_STR,pipeID.toString());
	    TextElement NameElement = basePipe.createElement(PIPE_NAME_STR,name);
	    TextElement TypeElement = basePipe.createElement(PIPE_TYPE_STR,type);
		basePipe.appendChild(IdElement);
		basePipe.appendChild(NameElement);
		basePipe.appendChild(TypeElement);

		return basePipe;
	}

	// ???????????????????? 
	private ModuleImplAdvertisement createPasswdMembershipPeerGroupModuleImplAdv(
			PeerGroup rootPeerGroup) {
		// Create a ModuleImpl Advertisement for the Passwd
		// Membership Service Take a allPurposePeerGroupImplAdv
		// ModuleImplAdvertisement parameter to
		// Clone some of its fields. It is easier than to recreate
		// everything from scratch
		// Try to locate where the PasswdMembership is within this
		// ModuleImplAdvertisement.
		// For a PeerGroup Module Impl, the list of the services
		// (including Membership) are located in the Param section
		ModuleImplAdvertisement allPurposePeerGroupImplAdv = null;
		try {
			allPurposePeerGroupImplAdv = rootPeerGroup
					.getAllPurposePeerGroupImplAdvertisement();
		} catch (java.lang.Exception e) {
			log.error("Can't Execute: getAllPurposePeerGroupImplAdvertisement();");
		}
		ModuleImplAdvertisement passwdMembershipPeerGroupModuleImplAdv = allPurposePeerGroupImplAdv;
		ModuleImplAdvertisement passwdMembershipServiceModuleImplAdv = null;
		StdPeerGroupParamAdv passwdMembershipPeerGroupParamAdv = null;
		try {
			passwdMembershipPeerGroupParamAdv = new StdPeerGroupParamAdv(
					allPurposePeerGroupImplAdv.getParam());
		} catch (Exception e) {
			log.error("Can't execute: StdPeerGroupParamAdv passwdMembershipPeerGroupParamAdv = new StdPeerGroupParamAdv (allPurposePeerGroupImplAdv.getParam());");
		}

		Hashtable allPurposePeerGroupServicesHashtable = new Hashtable();

		Map<ModuleClassID, Object> map = passwdMembershipPeerGroupParamAdv
				.getServices();
		Set<ModuleClassID> set = map.keySet();
		Iterator iter = set.iterator();
		Object obj;
		while (iter.hasNext()) {
			obj = iter.next();
			allPurposePeerGroupServicesHashtable.put(obj, map.get(obj));
		}

		Enumeration allPurposePeerGroupServicesEnumeration = allPurposePeerGroupServicesHashtable
				.keys();
		boolean membershipServiceFound = false;
		while ((!membershipServiceFound)
				&& (allPurposePeerGroupServicesEnumeration.hasMoreElements())) {
			Object allPurposePeerGroupServiceID = allPurposePeerGroupServicesEnumeration
					.nextElement();
			if (allPurposePeerGroupServiceID
					.equals(PeerGroup.membershipClassID)) {
				// allPurposePeerGroupMemershipServiceModuleImplAdv is
				// the all Purpose Mermbership Service for the all
				// purpose Peer Group Module Impl adv
				ModuleImplAdvertisement allPurposePeerGroupMemershipServiceModuleImplAdv = (ModuleImplAdvertisement) allPurposePeerGroupServicesHashtable
						.get(allPurposePeerGroupServiceID);
				// Create the passwdMembershipServiceModuleImplAdv
				passwdMembershipServiceModuleImplAdv = this
						.createPasswdMembershipServiceModuleImplAdv(allPurposePeerGroupMemershipServiceModuleImplAdv);
				// Remove the All purpose Membership Service implementation
				allPurposePeerGroupServicesHashtable
						.remove(allPurposePeerGroupServiceID);
				// And Replace it by the Passwd Membership Service
				// Implementation
				allPurposePeerGroupServicesHashtable.put(
						PeerGroup.membershipClassID,
						passwdMembershipServiceModuleImplAdv);
				membershipServiceFound = true;
				// Now the Service Advertisements are complete. Let's
				// update the passwdMembershipPeerGroupModuleImplAdv by
				// Updating its param
				passwdMembershipPeerGroupModuleImplAdv
						.setParam((Element) passwdMembershipPeerGroupParamAdv
								.getDocument(MimeMediaType.XMLUTF8));
				// Update its Spec ID This comes from the