/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.ode.clustering.hazelcast;

import com.hazelcast.config.Config;
import com.hazelcast.config.FileSystemXmlConfig;
import com.hazelcast.config.ListenerConfig;
import com.hazelcast.config.TopicConfig;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;
import com.hazelcast.core.ITopic;
import com.hazelcast.core.Member;
import com.hazelcast.core.MemberAttributeEvent;
import com.hazelcast.core.MembershipEvent;
import com.hazelcast.core.MembershipListener;
import com.hazelcast.core.Message;
import com.hazelcast.core.MessageListener;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.ode.bpel.clapi.*;

/**
 * This class implements necessary methods to build the cluster using hazelcast
 */
public class HazelcastClusterImpl implements ClusterManager, ProcessStoreClusterListener {
    private static final Logger __log = LoggerFactory.getLogger(HazelcastClusterImpl.class);

    private HazelcastInstance _hazelcastInstance;
    private boolean isMaster = false;
    private String nodeHostName;
    private String nodeID;
    private IMap<String, String> deployment_lock_map;
    private IMap<Long, Long> instance_lock_map;
    private ITopic<ProcessStoreClusterEvent> clusterDeploymentMessageTopic;
    private ClusterProcessStore _clusterProcessStore;
    private HazelcastDeploymentLock hazelcastDeploymentLock;
    private HazelcastInstanceLock hazelcastInstanceLock;
    private ClusterDeploymentMessageListener clusterDeploymentMessageListener;
    private ClusterMemberShipListener clusterMemberShipListener;
    private List<ClusterMemberListener> clusterMemberListenerList = null;

    public HazelcastClusterImpl() {
        clusterMemberShipListener = new ClusterMemberShipListener();
        clusterDeploymentMessageListener = new ClusterDeploymentMessageListener();
        clusterDeploymentMessageListener.registerClusterProcessStoreListener((ProcessStoreClusterListener)this);
        hazelcastDeploymentLock = new HazelcastDeploymentLock();
        hazelcastInstanceLock = new HazelcastInstanceLock();
    }


    public void init(File configRoot) {

        /*First,looks for the hazelcast.config system property. If it is set, its value is used as the path.
        Else it will load the hazelcast.xml file using FileSystemXmlConfig()*/

        String hzConfig = System.getProperty("hazelcast.config");
        if (hzConfig != null) _hazelcastInstance = Hazelcast.newHazelcastInstance();
        else {
            File hzXml = new File(configRoot, "hazelcast.xml");
            if (!hzXml.isFile())
                __log.error("hazelcast.xml does not exist or is not a file");
            else
                try {
                    Config config = loadConfig(hzXml);
                    _hazelcastInstance = Hazelcast.newHazelcastInstance(config);
                } catch (FileNotFoundException fnf) {
                    __log.error("",fnf);
                }
        }

        if (_hazelcastInstance != null) {
            // Registering this node in the cluster.
            //_hazelcastInstance.getCluster().addMembershipListener(new ClusterMemberShipListener());
            Member localMember = _hazelcastInstance.getCluster().getLocalMember();
            nodeHostName = localMember.getSocketAddress().getHostName() + ":" + localMember.getSocketAddress().getPort();
            nodeID = localMember.getUuid();
            __log.info("Registering HZ localMember:" + nodeHostName);

            deployment_lock_map = _hazelcastInstance.getMap(HazelcastConstants.ODE_CLUSTER_DEPLOYMENT_LOCK);
            instance_lock_map = _hazelcastInstance.getMap(HazelcastConstants.ODE_CLUSTER_PROCESS_INSTANCE_LOCK);
            clusterDeploymentMessageTopic = _hazelcastInstance.getTopic(HazelcastConstants.ODE_CLUSTER_DEPLOYMENT_TOPIC);

            hazelcastDeploymentLock.setLockMap(deployment_lock_map);
            hazelcastInstanceLock.setLockMap(instance_lock_map);
            markAsMaster();
        }
    }

    protected Config loadConfig(File hazelcastConfigFile) throws FileNotFoundException {
        Config config = new FileSystemXmlConfig(hazelcastConfigFile);

        //add Cluster membership listener
        ListenerConfig clusterMemberShipListenerConfig = new ListenerConfig();
        clusterMemberShipListenerConfig.setImplementation(clusterMemberShipListener);
        config.addListenerConfig(clusterMemberShipListenerConfig);

        //set topic message listener
        ListenerConfig topicListenerConfig = new ListenerConfig();
        topicListenerConfig.setImplementation(clusterDeploymentMessageListener);
        TopicConfig topicConfig = config.getTopicConfig(HazelcastConstants.ODE_CLUSTER_DEPLOYMENT_TOPIC);
        topicConfig.addMessageListenerConfig(topicListenerConfig);

        return config;
    }

    class ClusterMemberShipListener implements MembershipListener {

        public ClusterMemberShipListener() {
            clusterMemberListenerList = new ArrayList<ClusterMemberListener>();
        }

        public void registerClusterMemberListener(ClusterMemberListener listener) {
            clusterMemberListenerList.add(listener);
        }

        @Override
        public void memberAdded(MembershipEvent membershipEvent) {
            String eventNodeID = membershipEvent.getMember().getUuid();
            __log.info("Member Added " + eventNodeID);
            if (isMaster) {
                for (ClusterMemberListener listener : clusterMemberListenerList) {
                    listener.memberAdded(eventNodeID);
                }
            }
        }

        @Override
        public void memberRemoved(MembershipEvent membershipEvent) {
            String eventNodeID = membershipEvent.getMember().getUuid();
            __log.info("Member Removed " + eventNodeID);
            markAsMaster();
            if (isMaster) {
                for (ClusterMemberListener listener : clusterMemberListenerList) {
                    listener.memberRemoved(eventNodeID);
                }
            }
        }

        @Override
        public void memberAttributeChanged(MemberAttributeEvent memberAttributeEvent) {
            // Noting to do here.
        }
    }

    public void publishProcessStoreClusterEvent(ProcessStoreClusterEvent clusterEvent) {
        clusterEvent.setEventGeneratingNode(nodeID);
        __log.info("Send " + clusterEvent.getInfo() + " Cluster Message " + "for " + clusterEvent.getDuName() + " [" + nodeHostName + "]");
        clusterDeploymentMessageTopic.publish(clusterEvent);
    }


    class ClusterDeploymentMessageListener implements MessageListener<ProcessStoreClusterEvent> {
        List<ProcessStoreClusterListener> clusterProcessStoreListenerList = null;

        public ClusterDeploymentMessageListener() {
            clusterProcessStoreListenerList = new ArrayList<ProcessStoreClusterListener>();
        }

        public void registerClusterProcessStoreListener(ProcessStoreClusterListener listener) {
            clusterProcessStoreListenerList.add(listener);
        }

        @Override
        public void onMessage(Message<ProcessStoreClusterEvent> msg) {
            for (ProcessStoreClusterListener listener : clusterProcessStoreListenerList) {
                listener.onProcessStoreClusterEvent(msg.getMessageObject());
            }
        }
    }

    public void onProcessStoreClusterEvent(ProcessStoreClusterEvent message) {
        if (message instanceof ProcessStoreDeployedEvent) {
            ProcessStoreDeployedEvent event = (ProcessStoreDeployedEvent) message;
            String eventUuid = event.getEventGeneratingNode();
            if (!nodeID.equals(eventUuid)) {
                String duName = event.getDuName();
                __log.info("Receive " + event.getInfo() + " Cluster Message " + "for " + event.getDuName() + " [" + nodeHostName + "]");
                _clusterProcessStore.deployProcesses(duName);
            }
        }

        else if (message instanceof ProcessStoreUndeployedEvent) {
            ProcessStoreUndeployedEvent event = (ProcessStoreUndeployedEvent) message;
            String eventUuid = event.getEventGeneratingNode();
            if (!nodeID.equals(eventUuid)) {
                String duName = event.getDuName();
                __log.info("Receive " + event.getInfo() + "  Cluster Message " + "for " + event.getDuName() + " [" + nodeHostName + "]");
                _clusterProcessStore.undeployProcesses(duName);
            }
        }

    }

    private void markAsMaster() {
        Member member = _hazelcastInstance.getCluster().getMembers().iterator().next();
        if (member.localMember() && isMaster == false) {
            isMaster = true;
            for (ClusterMemberListener listener : clusterMemberListenerList) {
                listener.memberElectedAsMaster(nodeID);
            }
        }
        __log.info("Master node: " +isMaster);
    }

    public boolean isMaster() {
        return isMaster;
    }

    public String getNodeID() {
        return nodeID;
    }

    public void setClusterProcessStore(ClusterProcessStore store) {
        _clusterProcessStore = store;
    }

    public void registerClusterProcessStoreMessageListener(ProcessStoreClusterListener listener) {
        clusterDeploymentMessageListener.registerClusterProcessStoreListener(listener);
    }

    public void registerClusterMemberListener(ClusterMemberListener listener) {
        clusterMemberShipListener.registerClusterMemberListener(listener);
    }

    public void shutdown() {
        if (_hazelcastInstance != null) _hazelcastInstance.shutdown();
    }

    public ClusterLock<String> getDeploymentLock(){
        return (ClusterLock)hazelcastDeploymentLock;
    }

    public ClusterLock<Long> getInstanceLock(){
        return (ClusterLock)hazelcastInstanceLock;
    }

    public List<String> getActiveNodes() {
        List<String> nodeList = new ArrayList<String>();
        for(Member m : _hazelcastInstance.getCluster().getMembers())
          nodeList.add(m.getUuid()) ;
        return nodeList;
    }
}