/*
 * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.vpnservice.neutronvpn.l2gw;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
import org.opendaylight.vpnservice.utils.clustering.ClusteringUtils;
import org.opendaylight.vpnservice.datastoreutils.AsyncClusteredDataChangeListenerBase;
import org.opendaylight.vpnservice.neutronvpn.api.l2gw.L2GatewayDevice;
import org.opendaylight.vpnservice.neutronvpn.api.l2gw.utils.L2GatewayCacheUtils;
import org.opendaylight.vpnservice.utils.hwvtep.HwvtepSouthboundConstants;
import org.opendaylight.vpnservice.utils.hwvtep.HwvtepSouthboundUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.attributes.Devices;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.L2gateways;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateways.attributes.l2gateways.L2gateway;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;

public class L2GatewayListener extends AsyncClusteredDataChangeListenerBase<L2gateway, L2GatewayListener>
        implements AutoCloseable {
    private static final Logger LOG = LoggerFactory.getLogger(L2GatewayListener.class);

    private ListenerRegistration<DataChangeListener> listenerRegistration;
    private final DataBroker broker;
    private ItmRpcService itmRpcService;
    private EntityOwnershipService entityOwnershipService;
    private BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer;

    public L2GatewayListener(final DataBroker db, RpcProviderRegistry rpcRegistry,
            EntityOwnershipService entityOwnershipService,
            BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
        super(L2gateway.class, L2GatewayListener.class);
        broker = db;
        this.entityOwnershipService = entityOwnershipService;
        this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
        itmRpcService = rpcRegistry.getRpcService(ItmRpcService.class);
        registerListener(db);
    }

    @Override
    public void close() throws Exception {
        if (listenerRegistration != null) {
            try {
                listenerRegistration.close();
            } catch (final Exception e) {
                LOG.error("Error when cleaning up DataChangeListener.", e);
            }
            listenerRegistration = null;
        }
        LOG.info("L2 Gateway listener Closed");
    }

    private void registerListener(final DataBroker db) {
        try {
            listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
                    InstanceIdentifier.create(Neutron.class).child(L2gateways.class).child(L2gateway.class),
                    L2GatewayListener.this, DataChangeScope.SUBTREE);
        } catch (final Exception e) {
            LOG.error("Neutron Manager L2 Gateway DataChange listener registration fail!", e);
            throw new IllegalStateException("Neutron Manager L2 Gateway DataChange listener registration failed.", e);
        }
    }

    @Override
    protected void add(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
        LOG.info("Adding L2gateway with ID: {}", input.getUuid());

        List<Devices> l2Devices = input.getDevices();
        for (Devices l2Device : l2Devices) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Adding L2gateway device: {}", l2Device);
            }
            addL2Device(l2Device, input);
        }
    }

    @Override
    protected void remove(final InstanceIdentifier<L2gateway> identifier, final L2gateway input) {
        LOG.info("Removing L2gateway with ID: {}", input.getUuid());

        List<Devices> l2Devices = input.getDevices();
        for (Devices l2Device : l2Devices) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Removing L2gateway device: {}", l2Device);
            }
            removeL2Device(l2Device, input);
        }
    }

    @Override
    protected void update(InstanceIdentifier<L2gateway> identifier, L2gateway original, L2gateway update) {
        if (LOG.isTraceEnabled()) {
            LOG.trace("Updating L2gateway : key: " + identifier + ", original value=" + original + ", update value="
                    + update);
        }
    }

    private void addL2Device(Devices l2Device, L2gateway input) {
        final String l2DeviceName = l2Device.getDeviceName();
        L2GatewayDevice l2GwDevice = L2GatewayCacheUtils.getL2DeviceFromCache(l2DeviceName);
        if (l2GwDevice != null) {
            if (!L2GatewayUtils.isGatewayAssociatedToL2Device(l2GwDevice)
                    && L2GatewayUtils.isL2GwDeviceConnected(l2GwDevice)) {
                // VTEP already discovered; create ITM tunnels
                final String hwvtepId = l2GwDevice.getHwvtepNodeId();
                InstanceIdentifier<Node> iid = HwvtepSouthboundUtils.createInstanceIdentifier(new NodeId(hwvtepId));
                ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
                        entityOwnershipService, HwvtepSouthboundConstants.HWVTEP_ENTITY_TYPE,
                        bindingNormalizedNodeSerializer.toYangInstanceIdentifier(iid));
                final List<IpAddress> tunnelIps = l2GwDevice.getTunnelIps();
                Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
                    @Override
                    public void onSuccess(Boolean isOwner) {
                        if (isOwner) {
                            LOG.info("Creating ITM Tunnels for {} connected to cluster node owner", l2DeviceName);
                            for (IpAddress tunnelIp : tunnelIps) {
                                L2GatewayUtils.createItmTunnels(itmRpcService, hwvtepId, l2DeviceName, tunnelIp);
                            }
                        } else {
                            LOG.info("ITM Tunnels are not created on the cluster node as this is not owner for {}",
                                    l2DeviceName);
                        }
                    }

                    @Override
                    public void onFailure(Throwable error) {
                        LOG.error("Failed to create ITM tunnels", error);
                    }
                });
            } else {
                LOG.trace("ITM tunnels are already created for device {}", l2DeviceName);
            }
        } else {
            LOG.trace("{} is not connected; ITM tunnels will be created when device comes up", l2DeviceName);
            // Pre-provision scenario. Create L2GatewayDevice without VTEP
            // details for pushing configurations as soon as device discovered
            l2GwDevice = new L2GatewayDevice();
            l2GwDevice.setDeviceName(l2DeviceName);
            L2GatewayCacheUtils.addL2DeviceToCache(l2DeviceName, l2GwDevice);
        }
        l2GwDevice.addL2GatewayId(input.getUuid());
    }

    private void removeL2Device(Devices l2Device, L2gateway input) {
        final String l2DeviceName = l2Device.getDeviceName();
        L2GatewayDevice l2GwDevice = L2GatewayCacheUtils.getL2DeviceFromCache(l2DeviceName);
        if (l2GwDevice != null) {
            // Delete ITM tunnels if it's last Gateway deleted and device is connected
            // Also, do not delete device from cache if it's connected
            if (L2GatewayUtils.isLastL2GatewayBeingDeleted(l2GwDevice)) {
                if (L2GatewayUtils.isL2GwDeviceConnected(l2GwDevice)) {
                    l2GwDevice.removeL2GatewayId(input.getUuid());
                    // Delete ITM tunnels
                    final String hwvtepId = l2GwDevice.getHwvtepNodeId();
                    InstanceIdentifier<Node> iid = HwvtepSouthboundUtils.createInstanceIdentifier(new NodeId(hwvtepId));
                    ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
                            entityOwnershipService, HwvtepSouthboundConstants.HWVTEP_ENTITY_TYPE,
                            bindingNormalizedNodeSerializer.toYangInstanceIdentifier(iid));
                    final List<IpAddress> tunnelIps = l2GwDevice.getTunnelIps();
                    Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
                        @Override
                        public void onSuccess(Boolean isOwner) {
                            if (isOwner) {
                                LOG.info("Deleting ITM Tunnels for {} connected to cluster node owner", l2DeviceName);
                                for (IpAddress tunnelIp : tunnelIps) {
                                    L2GatewayUtils.deleteItmTunnels(itmRpcService, hwvtepId, l2DeviceName, tunnelIp);
                                }
                            } else {
                                LOG.info("ITM Tunnels are not deleted on the cluster node as this is not owner for {}",
                                        l2DeviceName);
                            }
                        }

                        @Override
                        public void onFailure(Throwable error) {
                            LOG.error("Failed to delete ITM tunnels", error);
                        }
                    });
                } else {
                    L2GatewayCacheUtils.removeL2DeviceFromCache(l2DeviceName);
                }
            } else {
                l2GwDevice.removeL2GatewayId(input.getUuid());
                LOG.trace("ITM tunnels are not deleted for {} as this device has other L2gateway associations",
                        l2DeviceName);
            }
        } else {
            LOG.error("Unable to find L2 Gateway details for {}", l2DeviceName);
        }
    }

    @Override
    protected InstanceIdentifier<L2gateway> getWildCardPath() {
        return InstanceIdentifier.create(L2gateway.class);
    }

    @Override
    protected ClusteredDataChangeListener getDataChangeListener() {
        return L2GatewayListener.this;
    }

    @Override
    protected DataChangeScope getDataChangeScope() {
        return AsyncDataBroker.DataChangeScope.BASE;
    }
}