package connex.core.Presence;

import connex.core.net.*;
import net.jxta.endpoint.Message;
import net.jxta.document.StructuredDocumentFactory;
import net.jxta.document.AdvertisementFactory;
import net.jxta.document.StructuredDocument;

import java.io.FileInputStream;
import net.jxta.document.XMLElement;
import net.jxta.document.MimeMediaType;
import org.apache.log4j.Logger;

import connex.core.WS.*;
import net.jxta.protocol.*;
import org.apache.log4j.Level;
import java.io.File;

import java.io.*;
import javax.swing.ImageIcon;
import net.jxta.document.Document;
import java.util.Hashtable;


public class PresenceService implements ConnectionClient {
    /**
     * @directed
     */
    private static PresenceService presService = null;
    private boolean start = false;
    private String status = PresenceProtocol.ONLINE;
    public static int maxRetry = 3;
    private int retry = 1;
    private Workspace ws;
    private File picsFolder = null;
    private final static Logger LOG = org.apache.log4j.Logger.getLogger(
            ProfileAdv.class.getName());

    /**
     * @directed
     * @clientRole create*/
    private ProfileAdv ownProfileAdv;
    private WorkspaceConnection wCon;
    private String ownBackDoorID;

    /**
     * @directed
     * @link aggregationByValue
     */
    private MessageProcessor mProcessor;
    /**
     * The HashTable containing the registered Members.
     * @directed
     * @link aggregation
     */
    private MemberCollection memCollection;

    /**
     * @link aggregationByValue
     * @directed*/
    private MessageQueue queue;

    /**
     * @directed
     * @link aggregationByValue
     */
    private StatusController sc;
    private Hashtable services;


    private PresenceService() {

    }

    public void init(Workspace ws) {
        LOG.setLevel(Level.INFO);
        this.ws = ws;
        wCon = (WorkspaceConnection) ConnectionFactory.newWorkspaceConnection(ws, this);


        ownProfileAdv = this.loadMyProfileAdv();
        mProcessor = new MessageProcessor(wCon);
        sc = new StatusController();

        memCollection = new MemberCollection();
        queue = new MessageQueue(mProcessor);

    }


    /**
     * Start the service.
     */
    public void start() throws IOException {

        if (!start) {
            if (wCon.connect()) {

                try {
                    ownBackDoorID = wCon.getMyBackDoorID();
                } catch (Exception ex1) {
                    ownBackDoorID = wCon.getMyBackDoorID();
                }

                setStatus(status);
                queue.start();
                sc.start();
                start = true;

                mProcessor.sendPresenceReq();

                if (LOG.isEnabledFor(Level.INFO)) {
                    LOG.info(" PresenceService started successfully");
                }
            } else {
                if (LOG.isEnabledFor(Level.INFO)) {
                    LOG.info(" PresenceService can't connect..  ");
                }
                if (retry <= maxRetry) {
                    LOG.info(" retry to connect  PresenceService;" + retry + " ..  ");
                    wCon.disConnect();
                    try {
                        Thread.currentThread().sleep(2000);
                    } catch (InterruptedException ex) {
                    }
                    retry++;
                    start();

                } else {
                    throw new IOException("PresenceService can't connect...");
                }

            }

        } else {
            if (LOG.isEnabledFor(Level.INFO)) {
                LOG.info(" PresenceService already started");
            }

        }

    }

    /**
     * Stop the service.
     */
    public void stop() {
        setStatus(PresenceProtocol.OFFLINE);
        mProcessor.sendStatusUpdate(getStatus());
        sc.stopIt();
        sc.interrupt();

        queue.stopIt();
        wCon.disConnect();
        start = false;

        memCollection.clear(); //.removeAll();
        presService = null;
        if (LOG.isEnabledFor(Level.INFO)) {
            LOG.info(" PresenceService stoped ");
        }

    }


    /**
     *  Register a listener which has to be notified.
     * @param Listener PresenceListener
     */
    public void addListener(PresenceListener Listener) {

        mProcessor.attach(Listener);

    }


    /**
     * Remove a given listener object from the service.
     * @param Listener PresenceListener
     */
    public void removeListener(PresenceListener Listener) {
        mProcessor.detach(Listener);
    }

    /**
     * Register a listener which has to be notified.
     * @param serviceLister ServiceListener
     */
    public void registerService(ServiceListener serviceLister) {
        // services.put(serviceID, servicelister);
        mProcessor.attachService(serviceLister.getID(), serviceLister);
        System.err.println("registered Service : " + serviceLister.getID());

    }

    /**
     *  Remove a given Service object from the service.
     * @param serviceListener ServiceListener
     */
    public void removeService(ServiceListener serviceListener) {
        mProcessor.detachService(serviceListener);
        LOG.info("Service removed :" + serviceListener.getID());
    }


    protected synchronized MessageProcessor getMsgProcessor() {
        return this.mProcessor;
    }

    public synchronized MemberCollection getMemberCollection() {
        return this.memCollection;
    }


    public PeerAdvertisement getmOwnPeerAdv() {
        return ws.getPeerGroup().getPeerAdvertisement();
    }

    public ProfileAdv getmOwnPprofileAdv() {
        return this.ownProfileAdv;
    }

    protected String getOwnBackDoorID() {
        return this.ownBackDoorID;
    }

    /**
     *
     * @param Id String
     * @return ImageIcon
     */
    public synchronized ImageIcon getPicture(String Id) {
        if (getMemberCollection().get(Id).getPicture().equals("default.jpg") ||
            getMemberCollection().get(Id).isPictureUpdated()) {

            mProcessor.sendPicReq(getMemberCollection().get(Id).
                                  getPresenceBackDoorID());

            return null;
        }

        return new ImageIcon(getMemberCollection().get(Id).getPicture());

    }

    public synchronized void getServicePipe(String membId, String serviceId) {
        String pipeId = getMemberCollection().get(membId).getServicePipe(
                serviceId);

        mProcessor.sendServiceReq(getMemberCollection().get(membId).
                                  getPresenceBackDoorID(), serviceId);

    }

    public synchronized Document getProfile(String Id) {
        if (getMemberCollection().get(Id).getProfileAdv() == null) {
            return null;
        }

        return getMemberCollection().get(Id).getProfileAdv().getDocument(
                new MimeMediaType("text",
                                  "xml"));

    }

    public void profileUpdated() {
        ownProfileAdv = null;
        ownProfileAdv = this.loadMyProfileAdv();

        mProcessor.sendPresenceUpdate();
    }

    public void pictureUpdated() {
        mProcessor.sendPicUpdate();

    }

    /**
     *
     * @return String
     */
    public String getClientName() {
        return "PresenceService";
    }

    /**
     * loads the own profile Advertisement
     * @return ProfileAdv
     */
    private ProfileAdv loadMyProfileAdv() {
        net.jxta.document.AdvertisementFactory.registerAdvertisementInstance(
                ProfileAdv.getAdvertisementType(),
                new ProfileAdv.Instantiator());
        ProfileAdv myProfileAdv = null;
        try {
            FileInputStream is = new FileInputStream(System.getProperty(
                    "JXTA_HOME") + File.separator +
                    "ProfileAdv.adv");
            StructuredDocument doc = StructuredDocumentFactory.
                                     newStructuredDocument(new MimeMediaType(
                                             "text", "xml"), is);
            doc.appendChild(doc.createElement("userID", ws.getPeerID()));
            XMLElement e = (XMLElement) doc.getParent();

            myProfileAdv = (ProfileAdv) AdvertisementFactory.newAdvertisement(
                    e);
            //System.exit(0);
            is.close();

        } catch (Exception ex) {
            LOG.error("error loading ownProfileAdvertisement");
        }

        return myProfileAdv;
    }

    /**
     * Method which implements the ConnectionClient interface, this
     *  is activated when the NetworkService receives Message for the Service.
     * @param msg Message
     */
    public void reciveMessage(Message msg) {

        queue.push(msg);

        //mp.process(msg);*/
    }

    protected File getPicsFolder() {
        if (picsFolder == null) {
            //createPicsFolder();
        }
        return ws.getWorkspaceFolder();
    }

    public String getStatus() {
        return status; }

  /*  protected void createPicsFolder() {

        picsFolder = new File(System.getProperty("JXTA_HOME")+File.separator+"cm",
                              ws.getPeerGroup().getPeerGroupID().toString().
                              substring(9));

        if (!picsFolder.exists()) {
            picsFolder.mkdir();
            if (LOG.isEnabledFor(Level.INFO)) {
                LOG.info(" PresencePicsFolder created ");
            }

        }
    }*/

    public static synchronized PresenceService getInstance() {
        if (presService == null) {
            presService = new PresenceService();
        }
        return presService;
    }

    public void closedFromRemote() {
    }

    public void setStatus(String status) {
        this.status = status;
    }
}