package connex.core.WS;


import net.jxta.peergroup.*;
import java.util.Collection;

import java.util.Vector;
import connex.app.LoadStatusListener;

public class WorkspaceManager {
    /**
     * @directed
     * @supplierRole create
     */
    private Workspace currentWorkspace;

    /**
     * @directed
     */
    private Config config = null;

    /**
     * @directed
     * @supplierRole use
     */
    private Boot boot = null;

    /**
     * @directed
     * @supplierRole create
     */
    private WorkspaceDiscovery disco;
    private Vector <WorkspaceJoinListener>joinListeners = new Vector<WorkspaceJoinListener>();
    protected static LoadStatusListener loadListener ;

    /**
     * @clientRole singleton*/
    private static WorkspaceManager wsm = null;

    private WorkspaceManager() {
        wsm = this;
    }

public void addloadStatusListener(LoadStatusListener loadListener){
    this.loadListener= loadListener;
}
    /**
     * Boot ConneX
     * @return boolean
     */
    public boolean isConfigured() {
        loadListener.setStatus("checking network configuration");
        if (config == null) {
            config = new Config();
        }
        return config.isPlatformConfigured();

    }

    /**
     * used to Congfiger JXTA platform
     * @param mode String
     * @param user String
     * @param pass String
     */

    public void configur(String mode, String user, String pass) {

        if (!isConfigured()) {
             loadListener.setStatus("creating new network Configuration");
            if (mode == "Work as Client") {
                config.configureAsEdge(user, pass);

            }
            if (mode == "Work as Server") {
                config.configureAsRendezvous(user, pass);
            }
        }
    }

    public boolean bootConneX() {
        loadListener.setStatus("loading network Configuration");
        if (boot == null) {
            boot = new Boot();

        }

        return boot.launchConneX();

    }



    public void searchWorkspace(String search, WorkspaceSearchListener listener) {
        disco = new WorkspaceDiscovery(listener);
        disco.activateDicovery(search);
    }
public void StopWorkspaceSearch(WorkspaceSearchListener listener){
    if(disco!=null){
        disco.deactivatediscovery(listener);
    }
}
    public void addWorkspaceJoinListener(WorkspaceJoinListener joinListener) {
        joinListeners.add(joinListener);
    }

    public static Workspace createWorkspace(String name,
                                            String description, String log,
                                            String password,
                                            long expiration, PeerGroupID id) throws
            Exception {

        return WorkspaceUtil.createWorkspace(name, description, log, password,
                                             expiration, null);
    }

    public static Collection getWorkspaces() {
        return WorkspaceUtil.getLocalWorkspaces(null);
    }

    public void leaveCurrentWorkspace() {
        WorkspaceUtil.leaveGroup(this.currentWorkspace);
    }

    public void setCurrentWorkspace(Workspace ws) {
        this.currentWorkspace = ws;

        for (int i = 0; i < joinListeners.size(); i++) {
            ((WorkspaceJoinListener) joinListeners.elementAt(i)).receiveJoinedWorkspace(ws);
        }

    }

    public void close(){
        for (int i = 0; i < joinListeners.size(); i++) {
           ((WorkspaceJoinListener) joinListeners.elementAt(i)).close();
       }
       boot.netPeerGroup.unref();
       System.exit(0);

    }


    public Workspace getCurrentWorkspace() {
        return currentWorkspace;
    }


    public static WorkspaceManager getInstance() {
        if (wsm == null) {
            return new WorkspaceManager();
        } else {
            return wsm;
        }

    }
}