/*
 *  Copyright 2016 Open Networking Laboratory
 *
 *  Licensed 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.onosproject.ui.impl.topo.model;

import org.onlab.osgi.DefaultServiceDirectory;
import org.onlab.osgi.ServiceDirectory;
import org.onosproject.cluster.ClusterEvent;
import org.onosproject.cluster.ClusterEventListener;
import org.onosproject.cluster.ClusterService;
import org.onosproject.incubator.net.PortStatisticsService;
import org.onosproject.incubator.net.tunnel.TunnelService;
import org.onosproject.mastership.MastershipEvent;
import org.onosproject.mastership.MastershipListener;
import org.onosproject.mastership.MastershipService;
import org.onosproject.net.device.DeviceEvent;
import org.onosproject.net.device.DeviceListener;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.flow.FlowRuleEvent;
import org.onosproject.net.flow.FlowRuleListener;
import org.onosproject.net.flow.FlowRuleService;
import org.onosproject.net.host.HostEvent;
import org.onosproject.net.host.HostListener;
import org.onosproject.net.host.HostService;
import org.onosproject.net.intent.IntentEvent;
import org.onosproject.net.intent.IntentListener;
import org.onosproject.net.intent.IntentService;
import org.onosproject.net.link.LinkEvent;
import org.onosproject.net.link.LinkListener;
import org.onosproject.net.link.LinkService;
import org.onosproject.net.region.RegionEvent;
import org.onosproject.net.region.RegionListener;
import org.onosproject.net.region.RegionService;
import org.onosproject.net.statistic.StatisticService;
import org.onosproject.net.topology.TopologyService;
import org.onosproject.ui.impl.topo.UiTopoSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashSet;
import java.util.Set;

/**
 * A lazily-initialized Singleton that creates and maintains the UI-model
 * of the network topology.
 */
public final class UiSharedTopologyModel {

    private static final Logger log =
            LoggerFactory.getLogger(UiSharedTopologyModel.class);

    private final ModelEventListener modelEventListener;

    private final Set<UiTopoSession> sessions = new HashSet<>();

    private UiSharedTopologyModel() {
        modelEventListener = new ModelEventListener().init();

        // TODO: build and maintain the state of the model
        // (1) query model for current state
        // (2) update state as model events arrive
    }

    /**
     * Registers a UI topology session with the topology model.
     *
     * @param session the session to register
     */
    public void register(UiTopoSession session) {
        log.info("Registering topology session {}", session);
        sessions.add(session);
    }

    /**
     * Unregisters a UI topology session from the topology model.
     *
     * @param session the session to unregister
     */
    public void unregister(UiTopoSession session) {
        log.info("Unregistering topology session {}", session);
        sessions.remove(session);
    }


    // TODO: notify registered sessions when changes happen to the model


    // ----------

    // inner class to encapsulate the model listeners
    private final class ModelEventListener {

        // TODO: Review - is this good enough? couldn't otherwise see how to inject
        private final ServiceDirectory directory = new DefaultServiceDirectory();

        private ClusterService clusterService;
        private MastershipService mastershipService;
        private RegionService regionService;
        private DeviceService deviceService;
        private LinkService linkService;
        private HostService hostService;
        private IntentService intentService;
        private FlowRuleService flowService;

        private StatisticService flowStatsService;
        private PortStatisticsService portStatsService;
        private TopologyService topologyService;
        private TunnelService tunnelService;

        private ModelEventListener init() {
            clusterService = directory.get(ClusterService.class);
            mastershipService = directory.get(MastershipService.class);
            regionService = directory.get(RegionService.class);
            deviceService = directory.get(DeviceService.class);
            linkService = directory.get(LinkService.class);
            hostService = directory.get(HostService.class);
            intentService = directory.get(IntentService.class);
            flowService = directory.get(FlowRuleService.class);

            // passive services (?) to whom we are not listening...
            flowStatsService = directory.get(StatisticService.class);
            portStatsService = directory.get(PortStatisticsService.class);
            topologyService = directory.get(TopologyService.class);
            tunnelService = directory.get(TunnelService.class);

            return this;
        }

        private class InternalClusterListener implements ClusterEventListener {
            @Override
            public void event(ClusterEvent event) {
                // TODO: handle cluster event
                // (1) emit cluster member event
            }
        }

        private class InternalMastershipListener implements MastershipListener {
            @Override
            public void event(MastershipEvent event) {
                // TODO: handle mastership event
                // (1) emit cluster member update for all members
                // (2) emit update device event for he whose mastership changed
            }
        }

        private class InternalRegionListener implements RegionListener {
            @Override
            public void event(RegionEvent event) {
                // TODO: handle region event
                // (1) emit region event
            }
        }

        private class InternalDeviceListener implements DeviceListener {
            @Override
            public void event(DeviceEvent event) {
                // TODO: handle device event
                // (1) emit device event
            }
        }

        private class InternalLinkListener implements LinkListener {
            @Override
            public void event(LinkEvent event) {
                // TODO: handle link event
                // (1) consolidate infrastructure links -> UiLink (?)
                // (2) emit link event
            }
        }

        private class InternalHostListener implements HostListener {
            @Override
            public void event(HostEvent event) {
                // TODO: handle host event
                // (1) emit host event
            }
        }

        private class InternalIntentListener implements IntentListener {
            @Override
            public void event(IntentEvent event) {
                // TODO: handle intent event
                // (1) update cache of intent counts?
            }
        }

        private class InternalFlowRuleListener implements FlowRuleListener {
            @Override
            public void event(FlowRuleEvent event) {
                // TODO: handle flowrule event
                // (1) update cache of flow counts?
            }
        }
    }

    // ----------

    /**
     * Bill Pugh Singleton pattern. INSTANCE won't be instantiated until the
     * LazyHolder class is loaded via a call to the instance() method below.
     */
    private static class LazyHolder {
        private static final UiSharedTopologyModel INSTANCE =
                new UiSharedTopologyModel();
    }

    /**
     * Returns a reference to the Singleton UI network topology model.
     *
     * @return the singleton topology model
     */
    public static UiSharedTopologyModel instance() {
        return LazyHolder.INSTANCE;
    }
}