package org.onlab.onos.sdnip;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.junit.Before;
import org.junit.Test;
import org.onlab.onos.ApplicationId;
import org.onlab.onos.net.ConnectPoint;
import org.onlab.onos.net.DefaultHost;
import org.onlab.onos.net.DeviceId;
import org.onlab.onos.net.Host;
import org.onlab.onos.net.HostId;
import org.onlab.onos.net.HostLocation;
import org.onlab.onos.net.PortNumber;
import org.onlab.onos.net.flow.DefaultTrafficSelector;
import org.onlab.onos.net.flow.DefaultTrafficTreatment;
import org.onlab.onos.net.flow.TrafficSelector;
import org.onlab.onos.net.flow.TrafficTreatment;
import org.onlab.onos.net.host.HostService;
import org.onlab.onos.net.intent.IntentService;
import org.onlab.onos.net.intent.MultiPointToSinglePointIntent;
import org.onlab.onos.net.provider.ProviderId;
import org.onlab.onos.sdnip.config.BgpPeer;
import org.onlab.onos.sdnip.config.Interface;
import org.onlab.onos.sdnip.config.SdnIpConfigService;
import org.onlab.packet.Ethernet;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onlab.util.TestUtils;
import org.onlab.util.TestUtils.TestUtilsException;

import com.google.common.collect.Sets;

/**
 * This class tests adding a route, updating a route, deleting a route,
 * and adding a route whose next hop is the local BGP speaker.
 */
public class RouterTest {

    private SdnIpConfigService sdnIpConfigService;
    private InterfaceService interfaceService;
    private IntentService intentService;
    private HostService hostService;

    private Map<IpAddress, BgpPeer> bgpPeers;
    private Map<IpAddress, BgpPeer> configuredPeers;
    private Set<Interface> interfaces;
    private Set<Interface> configuredInterfaces;

    private static final ApplicationId APPID = new ApplicationId() {
        @Override
        public short id() {
            return 1;
        }

        @Override
        public String name() {
            return "SDNIP";
        }
    };

    private Router router;

    @Before
    public void setUp() throws Exception {
        bgpPeers = setUpBgpPeers();
        interfaces = setUpInterfaces();
        initRouter();
    }

    /**
     * Initializes Router class.
     */
    private void initRouter() {

        intentService = createMock(IntentService.class);
        hostService = createMock(HostService.class);

        interfaceService = createMock(InterfaceService.class);
        expect(interfaceService.getInterfaces()).andReturn(
                interfaces).anyTimes();

        Set<IpPrefix> ipAddressesOnSw1Eth1 = new HashSet<IpPrefix>();
        ipAddressesOnSw1Eth1.add(IpPrefix.valueOf("192.168.10.0/24"));
        Interface expectedInterface =
                new Interface(new ConnectPoint(
                        DeviceId.deviceId("of:0000000000000001"),
                        PortNumber.portNumber("1")),
                        ipAddressesOnSw1Eth1,
                        MacAddress.valueOf("00:00:00:00:00:01"));
        ConnectPoint egressPoint = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000001"),
                PortNumber.portNumber(1));
        expect(interfaceService.getInterface(egressPoint)).andReturn(
                expectedInterface).anyTimes();

        Set<IpPrefix> ipAddressesOnSw2Eth1 = new HashSet<IpPrefix>();
        ipAddressesOnSw2Eth1.add(IpPrefix.valueOf("192.168.20.0/24"));
        Interface expectedInterfaceNew =
                new Interface(new ConnectPoint(
                        DeviceId.deviceId("of:0000000000000002"),
                        PortNumber.portNumber("1")),
                        ipAddressesOnSw2Eth1,
                        MacAddress.valueOf("00:00:00:00:00:02"));
        ConnectPoint egressPointNew = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000002"),
                PortNumber.portNumber(1));
        expect(interfaceService.getInterface(egressPointNew)).andReturn(
                expectedInterfaceNew).anyTimes();
        replay(interfaceService);

        sdnIpConfigService = createMock(SdnIpConfigService.class);
        expect(sdnIpConfigService.getBgpPeers()).andReturn(bgpPeers).anyTimes();
        replay(sdnIpConfigService);

        router = new Router(APPID, intentService,
                hostService, sdnIpConfigService, interfaceService);
    }

    /**
     * Sets up BGP peers in external networks.
     *
     * @return configured BGP peers as a Map from peer IP address to BgpPeer
     */
    private Map<IpAddress, BgpPeer> setUpBgpPeers() {

        configuredPeers = new HashMap<>();

        String peerSw1Eth1 = "192.168.10.1";
        configuredPeers.put(IpAddress.valueOf(peerSw1Eth1),
                new BgpPeer("00:00:00:00:00:00:00:01", 1, peerSw1Eth1));

        // Two BGP peers are connected to switch 2 port 1.
        String peer1Sw2Eth1 = "192.168.20.1";
        configuredPeers.put(IpAddress.valueOf(peer1Sw2Eth1),
                new BgpPeer("00:00:00:00:00:00:00:02", 1, peer1Sw2Eth1));

        String peer2Sw2Eth1 = "192.168.20.2";
        configuredPeers.put(IpAddress.valueOf(peer2Sw2Eth1),
                new BgpPeer("00:00:00:00:00:00:00:02", 1, peer2Sw2Eth1));

        return configuredPeers;
    }

    /**
     * Sets up logical interfaces, which emulate the configured interfaces
     * in SDN-IP application.
     *
     * @return configured interfaces as a Set
     */
    private Set<Interface> setUpInterfaces() {

        configuredInterfaces = Sets.newHashSet();

        Set<IpPrefix> ipAddressesOnSw1Eth1 = new HashSet<IpPrefix>();
        ipAddressesOnSw1Eth1.add(IpPrefix.valueOf("192.168.10.0/24"));
        configuredInterfaces.add(
                new Interface(new ConnectPoint(
                        DeviceId.deviceId("of:0000000000000001"),
                        PortNumber.portNumber(1)),
                        ipAddressesOnSw1Eth1,
                        MacAddress.valueOf("00:00:00:00:00:01")));

        Set<IpPrefix> ipAddressesOnSw2Eth1 = new HashSet<IpPrefix>();
        ipAddressesOnSw2Eth1.add(IpPrefix.valueOf("192.168.20.0/24"));
        configuredInterfaces.add(
                new Interface(new ConnectPoint(
                        DeviceId.deviceId("of:0000000000000002"),
                        PortNumber.portNumber(1)),
                        ipAddressesOnSw2Eth1,
                        MacAddress.valueOf("00:00:00:00:00:02")));

        Set<IpPrefix> ipAddressesOnSw3Eth1 = new HashSet<IpPrefix>();
        ipAddressesOnSw3Eth1.add(IpPrefix.valueOf("192.168.30.0/24"));
        configuredInterfaces.add(
                new Interface(new ConnectPoint(
                        DeviceId.deviceId("of:0000000000000003"),
                        PortNumber.portNumber(1)),
                        ipAddressesOnSw3Eth1,
                        MacAddress.valueOf("00:00:00:00:00:03")));

        return configuredInterfaces;
    }

    /**
     * This method tests adding a route entry.
     */
    @Test
    public void testProcessRouteAdd() throws TestUtilsException {

        // Construct a route entry
        RouteEntry routeEntry = new RouteEntry(
                IpPrefix.valueOf("1.1.1.0/24"),
                IpAddress.valueOf("192.168.10.1"));

        // Construct a MultiPointToSinglePointIntent intent
        TrafficSelector.Builder selectorBuilder =
                DefaultTrafficSelector.builder();
        selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
                routeEntry.prefix());

        TrafficTreatment.Builder treatmentBuilder =
                DefaultTrafficTreatment.builder();
        treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));

        Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000002"),
                PortNumber.portNumber("1")));
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000003"),
                PortNumber.portNumber("1")));

        ConnectPoint egressPoint = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000001"),
                PortNumber.portNumber("1"));

        MultiPointToSinglePointIntent intent =
                new MultiPointToSinglePointIntent(APPID,
                        selectorBuilder.build(), treatmentBuilder.build(),
                        ingressPoints, egressPoint);

        // Reset host service
        reset(hostService);
        Set<Host> hosts = new HashSet<Host>(1);
        Set<IpPrefix> ipPrefixes = new HashSet<IpPrefix>();
        ipPrefixes.add(IpPrefix.valueOf("192.168.10.1/32"));
        hosts.add(new DefaultHost(ProviderId.NONE, HostId.NONE,
                MacAddress.valueOf("00:00:00:00:00:01"), VlanId.NONE,
                new HostLocation(
                        DeviceId.deviceId("of:0000000000000001"),
                        PortNumber.portNumber(1), 1),
                        ipPrefixes));
        expect(hostService.getHostsByIp(
                IpPrefix.valueOf("192.168.10.1/32"))).andReturn(hosts);
        replay(hostService);

        // Set up test expectation
        reset(intentService);
        intentService.submit(intent);
        replay(intentService);

        // Call the processRouteAdd() method in Router class
        router.leaderChanged(true);
        TestUtils.setField(router, "isActivatedLeader", true);
        router.processRouteAdd(routeEntry);

        // Verify
        assertEquals(router.getRoutes().size(), 1);
        assertTrue(router.getRoutes().contains(routeEntry));
        assertEquals(router.getPushedRouteIntents().size(), 1);
        assertEquals(router.getPushedRouteIntents().iterator().next(),
                intent);
        verify(intentService);
    }

    /**
     * This method tests updating a route entry.
     *
     * @throws TestUtilsException
     */
    @Test
    public void testRouteUpdate() throws TestUtilsException {

        // Firstly add a route
        testProcessRouteAdd();

        // Construct the existing route entry
        RouteEntry routeEntry = new RouteEntry(
                IpPrefix.valueOf("1.1.1.0/24"),
                IpAddress.valueOf("192.168.10.1"));

        // Construct the existing MultiPointToSinglePointIntent intent
        TrafficSelector.Builder selectorBuilder =
                DefaultTrafficSelector.builder();
        selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
                routeEntry.prefix());

        TrafficTreatment.Builder treatmentBuilder =
                DefaultTrafficTreatment.builder();
        treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));

        ConnectPoint egressPoint = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000001"),
                PortNumber.portNumber("1"));

        Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000002"),
                PortNumber.portNumber("1")));
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000003"),
                PortNumber.portNumber("1")));

        MultiPointToSinglePointIntent intent =
                new MultiPointToSinglePointIntent(APPID,
                        selectorBuilder.build(), treatmentBuilder.build(),
                        ingressPoints, egressPoint);

        // Start to construct a new route entry and new intent
        RouteEntry routeEntryUpdate = new RouteEntry(
                IpPrefix.valueOf("1.1.1.0/24"),
                IpAddress.valueOf("192.168.20.1"));

        // Construct a new MultiPointToSinglePointIntent intent
        TrafficSelector.Builder selectorBuilderNew =
                DefaultTrafficSelector.builder();
        selectorBuilderNew.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
                routeEntryUpdate.prefix());

        TrafficTreatment.Builder treatmentBuilderNew =
                DefaultTrafficTreatment.builder();
        treatmentBuilderNew.setEthDst(MacAddress.valueOf("00:00:00:00:00:02"));

        ConnectPoint egressPointNew = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000002"),
                PortNumber.portNumber("1"));

        Set<ConnectPoint> ingressPointsNew = new HashSet<ConnectPoint>();
        ingressPointsNew.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000001"),
                PortNumber.portNumber("1")));
        ingressPointsNew.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000003"),
                PortNumber.portNumber("1")));

        MultiPointToSinglePointIntent intentNew =
                new MultiPointToSinglePointIntent(APPID,
                        selectorBuilderNew.build(),
                        treatmentBuilderNew.build(),
                        ingressPointsNew, egressPointNew);

        // Reset host service
        reset(hostService);
        Set<Host> hosts = new HashSet<Host>(1);
        Set<IpPrefix> ipPrefixes = new HashSet<IpPrefix>();
        ipPrefixes.add(IpPrefix.valueOf("192.168.20.1/32"));
        hosts.add(new DefaultHost(ProviderId.NONE, HostId.NONE,
                MacAddress.valueOf("00:00:00:00:00:02"), VlanId.NONE,
                new HostLocation(
                        DeviceId.deviceId("of:0000000000000002"),
                        PortNumber.portNumber(1), 1),
                        ipPrefixes));
        expect(hostService.getHostsByIp(
                IpPrefix.valueOf("192.168.20.1/32"))).andReturn(hosts);
        replay(hostService);

        // Set up test expectation
        reset(intentService);
        intentService.withdraw(intent);
        intentService.submit(intentNew);
        replay(intentService);

        // Call the processRouteAdd() method in Router class
        router.leaderChanged(true);
        TestUtils.setField(router, "isActivatedLeader", true);
        router.processRouteAdd(routeEntryUpdate);

        // Verify
        assertEquals(router.getRoutes().size(), 1);
        assertTrue(router.getRoutes().contains(routeEntryUpdate));
        assertEquals(router.getPushedRouteIntents().size(), 1);
        assertEquals(router.getPushedRouteIntents().iterator().next(),
                intentNew);
        verify(intentService);
    }

    /**
     * This method tests deleting a route entry.
     */
    @Test
    public void testProcessRouteDelete() throws TestUtilsException {

        // Firstly add a route
        testProcessRouteAdd();

        // Construct the existing route entry
        RouteEntry routeEntry = new RouteEntry(
                IpPrefix.valueOf("1.1.1.0/24"),
                IpAddress.valueOf("192.168.10.1"));

        // Construct the existing MultiPointToSinglePointIntent intent
        TrafficSelector.Builder selectorBuilder =
                DefaultTrafficSelector.builder();
        selectorBuilder.matchEthType(Ethernet.TYPE_IPV4).matchIPDst(
                routeEntry.prefix());

        TrafficTreatment.Builder treatmentBuilder =
                DefaultTrafficTreatment.builder();
        treatmentBuilder.setEthDst(MacAddress.valueOf("00:00:00:00:00:01"));

        ConnectPoint egressPoint = new ConnectPoint(
                DeviceId.deviceId("of:0000000000000001"),
                PortNumber.portNumber("1"));

        Set<ConnectPoint> ingressPoints = new HashSet<ConnectPoint>();
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000002"),
                PortNumber.portNumber("1")));
        ingressPoints.add(new ConnectPoint(
                DeviceId.deviceId("of:0000000000000003"),
                PortNumber.portNumber("1")));

        MultiPointToSinglePointIntent intent =
                new MultiPointToSinglePointIntent(APPID,
                        selectorBuilder.build(), treatmentBuilder.build(),
                        ingressPoints, egressPoint);

        // Set up expectation
        reset(intentService);
        intentService.withdraw(intent);
        replay(intentService);

        // Call route deleting method in Router class
        router.leaderChanged(true);
        TestUtils.setField(router, "isActivatedLeader", true);
        router.processRouteDelete(routeEntry);

        // Verify
        assertEquals(router.getRoutes().size(), 0);
        assertEquals(router.getPushedRouteIntents().size(), 0);
        verify(intentService);
    }

    /**
     * This method tests when the next hop of a route is the local BGP speaker.
     *
     * @throws TestUtilsException
     */
    @Test
    public void testLocalRouteAdd() throws TestUtilsException {

        // Construct a route entry, the next hop is the local BGP speaker
        RouteEntry routeEntry = new RouteEntry(
                IpPrefix.valueOf("1.1.1.0/24"), IpAddress.valueOf("0.0.0.0"));

        // Reset intentService to check whether the submit method is called
        reset(intentService);
        replay(intentService);

        // Call the processRouteAdd() method in Router class
        router.leaderChanged(true);
        TestUtils.setField(router, "isActivatedLeader", true);
        router.processRouteAdd(routeEntry);

        // Verify
        assertEquals(router.getRoutes().size(), 1);
        assertTrue(router.getRoutes().contains(routeEntry));
        assertEquals(router.getPushedRouteIntents().size(), 0);
        verify(intentService);
    }
}