/*
 * Copyright 2017-present 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.drivers.lisp.extensions;

import com.fasterxml.jackson.databind.JsonNode;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.testing.EqualsTester;
import org.hamcrest.MatcherAssert;
import org.junit.Before;
import org.junit.Test;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onosproject.codec.CodecContext;
import org.onosproject.codec.impl.CodecManager;
import org.onosproject.drivers.lisp.extensions.codec.LispAppDataAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispAsAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispGcAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispListAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispMappingExtensionCodecContextAdapter;
import org.onosproject.drivers.lisp.extensions.codec.LispMulticastAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispNatAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispNonceAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispSegmentAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispSrcDstAddressCodecTest;
import org.onosproject.drivers.lisp.extensions.codec.LispTeAddressCodecTest;
import org.onosproject.lisp.msg.types.LispAfiAddress;
import org.onosproject.lisp.msg.types.LispIpv4Address;
import org.onosproject.lisp.msg.types.LispIpv6Address;
import org.onosproject.lisp.msg.types.lcaf.LispAppDataLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispAsLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispGeoCoordinateLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispListLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispMulticastLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNatLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNonceLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSegmentLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSourceDestLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeRecord;
import org.onosproject.mapping.addresses.ExtensionMappingAddress;
import org.onosproject.mapping.addresses.ExtensionMappingAddressType;
import org.onosproject.mapping.addresses.MappingAddress;
import org.onosproject.mapping.addresses.MappingAddresses;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.Assert.assertTrue;
import static org.onosproject.drivers.lisp.extensions.LispExtensionMappingAddressInterpreter.*;
import static org.onosproject.mapping.addresses.ExtensionMappingAddressType.ExtensionMappingAddressTypes.*;
/**
 * Unit tests for LispExtensionMappingAddressInterpreter.
 */
public class LispExtensionMappingAddressInterpreterTest {

    private static final String IPV4_STRING = "1.2.3.4";
    private static final String IPV6_STRING = "1111:2222:3333:4444:5555:6666:7777:8886";
    private static final IpPrefix IPV4_PREFIX = IpPrefix.valueOf(IPV4_STRING + "/32");
    private static final IpPrefix IPV6_PREFIX = IpPrefix.valueOf(IPV6_STRING + "/128");
    private static final IpAddress IPV4_ADDRESS = IpAddress.valueOf(IPV4_STRING);
    private static final IpAddress IPV6_ADDRESS = IpAddress.valueOf(IPV6_STRING);

    private static final int UNIQUE_INT = 1;
    private static final short UNIQUE_SHORT = (short) 1;
    private static final byte UNIQUE_BYTE = (byte) 1;
    private static final boolean UNIQUE_BOOLEAN = true;

    private LispExtensionMappingAddressInterpreter interpreter;

    private CodecContext context;
    private LispMappingExtensionCodecRegistrator registrator;

    private ExtensionMappingAddress listExtAddress;
    private ExtensionMappingAddress segmentExtAddress;
    private ExtensionMappingAddress asExtAddress;
    private ExtensionMappingAddress appDataExtAddress;
    private ExtensionMappingAddress gcExtAddress;
    private ExtensionMappingAddress natExtAddress;
    private ExtensionMappingAddress nonceExtAddress;
    private ExtensionMappingAddress multicastExtAddress;
    private ExtensionMappingAddress teExtAddress;
    private ExtensionMappingAddress srcDstExtAddress;

    private LispLcafAddress listLcafAddress;
    private LispLcafAddress segmentLcafAddress;
    private LispLcafAddress asLcafAddress;
    private LispLcafAddress appDataLcafAddress;
    private LispLcafAddress gcLcafAddress;
    private LispLcafAddress natLcafAddress;
    private LispLcafAddress nonceLcafAddress;
    private LispLcafAddress multicastLcafAddress;
    private LispLcafAddress teLcafAddress;
    private LispLcafAddress srcDstLcafAddress;

    @Before
    public void setUp() {
        interpreter = new LispExtensionMappingAddressInterpreter();
        initExtAddresses();
        initLcafAddresses();

        CodecManager manager = new CodecManager();
        registrator = new LispMappingExtensionCodecRegistrator();
        registrator.codecService = manager;
        registrator.activate();

        context = new LispMappingExtensionCodecContextAdapter(registrator.codecService);
    }

    /**
     * Initializes all extension mapping addresses.
     */
    private void initExtAddresses() {
        listExtAddress = getExtMappingAddress(LIST_ADDRESS.type());
        segmentExtAddress = getExtMappingAddress(SEGMENT_ADDRESS.type());
        asExtAddress = getExtMappingAddress(AS_ADDRESS.type());
        appDataExtAddress = getExtMappingAddress(APPLICATION_DATA_ADDRESS.type());
        gcExtAddress = getExtMappingAddress(GEO_COORDINATE_ADDRESS.type());
        natExtAddress = getExtMappingAddress(NAT_ADDRESS.type());
        nonceExtAddress = getExtMappingAddress(NONCE_ADDRESS.type());
        multicastExtAddress = getExtMappingAddress(MULTICAST_ADDRESS.type());
        teExtAddress = getExtMappingAddress(TRAFFIC_ENGINEERING_ADDRESS.type());
        srcDstExtAddress = getExtMappingAddress(SOURCE_DEST_ADDRESS.type());
    }

    /**
     * Initializes all LCAF addresses.
     */
    private void initLcafAddresses() {
        listLcafAddress = getLcafMappingAddress(LIST_ADDRESS.type());
        segmentLcafAddress = getLcafMappingAddress(SEGMENT_ADDRESS.type());
        asLcafAddress = getLcafMappingAddress(AS_ADDRESS.type());
        appDataLcafAddress = getLcafMappingAddress(APPLICATION_DATA_ADDRESS.type());
        gcLcafAddress = getLcafMappingAddress(GEO_COORDINATE_ADDRESS.type());
        natLcafAddress = getLcafMappingAddress(NAT_ADDRESS.type());
        nonceLcafAddress = getLcafMappingAddress(NONCE_ADDRESS.type());
        multicastLcafAddress = getLcafMappingAddress(MULTICAST_ADDRESS.type());
        teLcafAddress = getLcafMappingAddress(TRAFFIC_ENGINEERING_ADDRESS.type());
        srcDstLcafAddress = getLcafMappingAddress(SOURCE_DEST_ADDRESS.type());
    }

    /**
     * Tests supportability of a certain LISP extension mapping address.
     */
    @Test
    public void testSupported() {
        assertTrue("List extension address should be supported",
                interpreter.supported(listExtAddress.type()));
        assertTrue("Segment extension address should be supported",
                interpreter.supported(segmentExtAddress.type()));
        assertTrue("AS extension address should be supported",
                interpreter.supported(asExtAddress.type()));
        assertTrue("Application data extension address should be supported",
                interpreter.supported(appDataExtAddress.type()));
        assertTrue("Geo Coordinate extension address should be supported",
                interpreter.supported(gcExtAddress.type()));
        assertTrue("NAT extension address should be supported ",
                interpreter.supported(natExtAddress.type()));
        assertTrue("Nonce extension address should be supported",
                interpreter.supported(nonceExtAddress.type()));
        assertTrue("Multicast extension address should be supported",
                interpreter.supported(multicastExtAddress.type()));
        assertTrue("Traffic engineering extension address should be supported",
                interpreter.supported(teExtAddress.type()));
        assertTrue("Source Destination extension address should be supported",
                interpreter.supported(srcDstExtAddress.type()));
    }

    /**
     * Tests conversion from LISP extension mapping address to LCAF address.
     */
    @Test
    public void testMapMappingAddress() {

        new EqualsTester()
                .addEqualityGroup(listLcafAddress, interpreter.mapMappingAddress(listExtAddress))
                .addEqualityGroup(segmentLcafAddress, interpreter.mapMappingAddress(segmentExtAddress))
                .addEqualityGroup(asLcafAddress, interpreter.mapMappingAddress(asExtAddress))
                .addEqualityGroup(appDataLcafAddress, interpreter.mapMappingAddress(appDataExtAddress))
                .addEqualityGroup(gcLcafAddress, interpreter.mapMappingAddress(gcExtAddress))
                .addEqualityGroup(natLcafAddress, interpreter.mapMappingAddress(natExtAddress))
                .addEqualityGroup(nonceLcafAddress, interpreter.mapMappingAddress(nonceExtAddress))
                .addEqualityGroup(multicastLcafAddress, interpreter.mapMappingAddress(multicastExtAddress))
                .addEqualityGroup(teLcafAddress, interpreter.mapMappingAddress(teExtAddress))
                .addEqualityGroup(srcDstLcafAddress, interpreter.mapMappingAddress(srcDstExtAddress))
                .testEquals();
    }

    /**
     * Tests conversion from LCAF address to LISP extension mapping address.
     */
    @Test
    public void testMapLcafAddress() {

        new EqualsTester()
                .addEqualityGroup(listExtAddress, interpreter.mapLcafAddress(listLcafAddress))
                .addEqualityGroup(segmentExtAddress, interpreter.mapLcafAddress(segmentLcafAddress))
                .addEqualityGroup(asExtAddress, interpreter.mapLcafAddress(asLcafAddress))
                .addEqualityGroup(appDataExtAddress, interpreter.mapLcafAddress(appDataLcafAddress))
                .addEqualityGroup(gcExtAddress, interpreter.mapLcafAddress(gcLcafAddress))
                .addEqualityGroup(natExtAddress, interpreter.mapLcafAddress(natLcafAddress))
                .addEqualityGroup(nonceExtAddress, interpreter.mapLcafAddress(nonceLcafAddress))
                .addEqualityGroup(multicastExtAddress, interpreter.mapLcafAddress(multicastLcafAddress))
                .addEqualityGroup(teExtAddress, interpreter.mapLcafAddress(teLcafAddress))
                .addEqualityGroup(srcDstExtAddress, interpreter.mapLcafAddress(srcDstLcafAddress))
                .testEquals();
    }

    /**
     * Tests encoding of an ExtensionMappingAddress object.
     */
    @Test
    public void testAddressEncode() {
        JsonNode listAddressJson =
                interpreter.encode(listExtAddress, context).get(LISP_LIST_ADDRESS);
        JsonNode segmentAddressJson =
                interpreter.encode(segmentExtAddress, context).get(LISP_SEGMENT_ADDRESS);
        JsonNode asAddressJson =
                interpreter.encode(asExtAddress, context).get(LISP_AS_ADDRESS);
        JsonNode appDataAddressJson =
                interpreter.encode(appDataExtAddress, context).get(LISP_APPLICATION_DATA_ADDRESS);
        JsonNode gcAddressJson =
                interpreter.encode(gcExtAddress, context).get(LISP_GEO_COORDINATE_ADDRESS);
        JsonNode natAddressJson =
                interpreter.encode(natExtAddress, context).get(LISP_NAT_ADDRESS);
        JsonNode nonceAddressJson =
                interpreter.encode(nonceExtAddress, context).get(LISP_NONCE_ADDRESS);
        JsonNode multicastAddressJson =
                interpreter.encode(multicastExtAddress, context).get(LISP_MULTICAST_ADDRESS);
        JsonNode teAddressJson =
                interpreter.encode(teExtAddress, context).get(LISP_TRAFFIC_ENGINEERING_ADDRESS);
        JsonNode srcDstAddressJson =
                interpreter.encode(srcDstExtAddress, context).get(LISP_SOURCE_DEST_ADDRESS);

        MatcherAssert.assertThat("errors in encoding List address JSON",
                listAddressJson, LispListAddressCodecTest.LispListAddressJsonMatcher
                        .matchesListAddress((LispListAddress) listExtAddress));

        MatcherAssert.assertThat("errors in encoding Segment address JSON",
                segmentAddressJson, LispSegmentAddressCodecTest.LispSegmentAddressJsonMatcher
                        .matchesSegmentAddress((LispSegmentAddress) segmentExtAddress));

        MatcherAssert.assertThat("errors in encoding AS address JSON",
                asAddressJson, LispAsAddressCodecTest.LispAsAddressJsonMatcher
                        .matchesAsAddress((LispAsAddress) asExtAddress));

        MatcherAssert.assertThat("errors in encoding AppData address JSON",
                appDataAddressJson, LispAppDataAddressCodecTest.LispAppDataAddressJsonMatcher
                        .matchesAppDataAddress((LispAppDataAddress) appDataExtAddress));

        MatcherAssert.assertThat("errors in encoding GC address JSON",
                gcAddressJson, LispGcAddressCodecTest.LispGcAddressJsonMatcher
                        .matchesGcAddress((LispGcAddress) gcExtAddress));

        MatcherAssert.assertThat("errors in encoding NAT address JSON",
                natAddressJson, LispNatAddressCodecTest.LispNatAddressJsonMatcher
                        .matchesNatAddress((LispNatAddress) natExtAddress));

        MatcherAssert.assertThat("errors in encoding Nonce address JSON",
                nonceAddressJson, LispNonceAddressCodecTest.LispNonceAddressJsonMatcher
                        .matchesNonceAddress((LispNonceAddress) nonceExtAddress));

        MatcherAssert.assertThat("errors in encoding Multicast address JSON",
                multicastAddressJson, LispMulticastAddressCodecTest.LispMulticastAddressJsonMatcher
                        .matchesMulticastAddress((LispMulticastAddress) multicastExtAddress));

        MatcherAssert.assertThat("errors in encoding TE address JSON",
                teAddressJson, LispTeAddressCodecTest.LispTeAddressJsonMatcher
                        .matchesTeAddress((LispTeAddress) teExtAddress));

        MatcherAssert.assertThat("errors in encoding SrcDst address JSON",
                srcDstAddressJson, LispSrcDstAddressCodecTest.LispSrcDstAddressJsonMatcher
                        .matchesSrcDstAddress((LispSrcDstAddress) srcDstExtAddress));
    }

    /**
     * Tests decoding of an ExtensionMappingAddress JSON object.
     */
    @Test
    public void testAddressDecode() throws IOException {
        List<ExtensionMappingAddress> addresses =
                getLispExtensionMappingAddresses("LispExtensionMappingAddress.json");

        new EqualsTester()
                .addEqualityGroup(addresses.get(0), listExtAddress)
                .addEqualityGroup(addresses.get(1), segmentExtAddress)
                .addEqualityGroup(addresses.get(2), asExtAddress)
                .addEqualityGroup(addresses.get(3), appDataExtAddress)
                .addEqualityGroup(addresses.get(4), gcExtAddress)
                .addEqualityGroup(addresses.get(5), natExtAddress)
                .addEqualityGroup(addresses.get(6), nonceExtAddress)
                .addEqualityGroup(addresses.get(7), multicastExtAddress)
                .addEqualityGroup(addresses.get(8), teExtAddress)
                .addEqualityGroup(addresses.get(9), srcDstExtAddress)
                .testEquals();
    }

    /**
     * Reads in a collection of LispExtensionMappingAddresses from the given resource and decodes it.
     *
     * @param resourceName resource to use to read the JSON for the rule
     * @return decoded LispExtensionMappingAddresses
     * @throws IOException if processing the resource fails
     */
    private List<ExtensionMappingAddress> getLispExtensionMappingAddresses(String resourceName)
            throws IOException {
        InputStream jsonStream = LispExtensionMappingAddressInterpreterTest.class
                                 .getResourceAsStream(resourceName);
        JsonNode json = context.mapper().readTree(jsonStream);
        assertThat("JSON string should not be null", json, notNullValue());

        final List<ExtensionMappingAddress> addresses = Lists.newArrayList();

        for (int addrIndex = 0; addrIndex < json.size(); addrIndex++) {
            ExtensionMappingAddress address = interpreter.decode(json.get(addrIndex).deepCopy(), context);
            assertThat("decoded address should not be null", address, notNullValue());
            addresses.add(address);
        }

        return addresses;
    }

    private LispLcafAddress getLcafMappingAddress(ExtensionMappingAddressType type) {
        LispLcafAddress address = null;

        LispAfiAddress ipv4Addr = new LispIpv4Address(IPV4_ADDRESS);
        LispAfiAddress ipv6Addr = new LispIpv6Address(IPV6_ADDRESS);

        if (type.equals(LIST_ADDRESS.type())) {
            address = new LispListLcafAddress(ImmutableList.of(ipv4Addr, ipv6Addr));
        }

        if (type.equals(SEGMENT_ADDRESS.type())) {
            address = new LispSegmentLcafAddress.SegmentAddressBuilder()
                                .withInstanceId(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(AS_ADDRESS.type())) {
            address = new LispAsLcafAddress.AsAddressBuilder()
                                .withAsNumber(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
            address = new LispAppDataLcafAddress.AppDataAddressBuilder()
                                .withProtocol(UNIQUE_BYTE)
                                .withIpTos(UNIQUE_INT)
                                .withLocalPortLow(UNIQUE_SHORT)
                                .withLocalPortHigh(UNIQUE_SHORT)
                                .withRemotePortLow(UNIQUE_SHORT)
                                .withRemotePortHigh(UNIQUE_SHORT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
            address = new LispGeoCoordinateLcafAddress.GeoCoordinateAddressBuilder()
                                .withIsNorth(UNIQUE_BOOLEAN)
                                .withLatitudeDegree(UNIQUE_SHORT)
                                .withLatitudeMinute(UNIQUE_BYTE)
                                .withLatitudeSecond(UNIQUE_BYTE)
                                .withIsEast(UNIQUE_BOOLEAN)
                                .withLongitudeDegree(UNIQUE_SHORT)
                                .withLongitudeMinute(UNIQUE_BYTE)
                                .withLongitudeSecond(UNIQUE_BYTE)
                                .withAltitude(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(NAT_ADDRESS.type())) {
            address = new LispNatLcafAddress.NatAddressBuilder()
                                .withMsUdpPortNumber(UNIQUE_SHORT)
                                .withEtrUdpPortNumber(UNIQUE_SHORT)
                                .withGlobalEtrRlocAddress(ipv4Addr)
                                .withMsRlocAddress(ipv4Addr)
                                .withPrivateEtrRlocAddress(ipv4Addr)
                                .withRtrRlocAddresses(ImmutableList.of(ipv4Addr, ipv6Addr))
                                .build();
        }

        if (type.equals(NONCE_ADDRESS.type())) {
            address = new LispNonceLcafAddress.NonceAddressBuilder()
                                .withNonce(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(MULTICAST_ADDRESS.type())) {
            address = new LispMulticastLcafAddress.MulticastAddressBuilder()
                                .withInstanceId(UNIQUE_INT)
                                .withSrcMaskLength(UNIQUE_BYTE)
                                .withSrcAddress(ipv4Addr)
                                .withGrpMaskLength(UNIQUE_BYTE)
                                .withGrpAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
            LispTeRecord tr = new LispTeRecord.TeRecordBuilder()
                                .withIsLookup(UNIQUE_BOOLEAN)
                                .withIsRlocProbe(UNIQUE_BOOLEAN)
                                .withIsStrict(UNIQUE_BOOLEAN)
                                .withRtrRlocAddress(ipv4Addr)
                                .build();

            address = new LispTeLcafAddress.TeAddressBuilder()
                                .withTeRecords(ImmutableList.of(tr))
                                .build();
        }

        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
            address = new LispSourceDestLcafAddress.SourceDestAddressBuilder()
                                .withSrcMaskLength(UNIQUE_BYTE)
                                .withSrcPrefix(ipv4Addr)
                                .withDstMaskLength(UNIQUE_BYTE)
                                .withDstPrefix(ipv4Addr)
                                .build();
        }

        return address;
    }

    private ExtensionMappingAddress getExtMappingAddress(ExtensionMappingAddressType type) {

        ExtensionMappingAddress address = null;

        MappingAddress ipv4Addr = MappingAddresses.ipv4MappingAddress(IPV4_PREFIX);
        MappingAddress ipv6Addr = MappingAddresses.ipv6MappingAddress(IPV6_PREFIX);

        if (type.equals(LIST_ADDRESS.type())) {
            address = new LispListAddress.Builder()
                                .withIpv4(ipv4Addr)
                                .withIpv6(ipv6Addr)
                                .build();
        }

        if (type.equals(SEGMENT_ADDRESS.type())) {
            address = new LispSegmentAddress.Builder()
                                .withInstanceId(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(AS_ADDRESS.type())) {
            address = new LispAsAddress.Builder()
                                .withAsNumber(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
            address = new LispAppDataAddress.Builder()
                                .withProtocol(UNIQUE_BYTE)
                                .withIpTos(UNIQUE_INT)
                                .withLocalPortLow(UNIQUE_SHORT)
                                .withLocalPortHigh(UNIQUE_SHORT)
                                .withRemotePortLow(UNIQUE_SHORT)
                                .withRemotePortHigh(UNIQUE_SHORT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
            address = new LispGcAddress.Builder()
                                .withIsNorth(UNIQUE_BOOLEAN)
                                .withLatitudeDegree(UNIQUE_SHORT)
                                .withLatitudeMinute(UNIQUE_BYTE)
                                .withLatitudeSecond(UNIQUE_BYTE)
                                .withIsEast(UNIQUE_BOOLEAN)
                                .withLongitudeDegree(UNIQUE_SHORT)
                                .withLongitudeMinute(UNIQUE_BYTE)
                                .withLongitudeSecond(UNIQUE_BYTE)
                                .withAltitude(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(NAT_ADDRESS.type())) {
            address = new LispNatAddress.Builder()
                                .withMsUdpPortNumber(UNIQUE_SHORT)
                                .withEtrUdpPortNumber(UNIQUE_SHORT)
                                .withGlobalEtrRlocAddress(ipv4Addr)
                                .withMsRlocAddress(ipv4Addr)
                                .withPrivateEtrRlocAddress(ipv4Addr)
                                .withRtrRlocAddresses(ImmutableList.of(ipv4Addr, ipv6Addr))
                                .build();
        }

        if (type.equals(NONCE_ADDRESS.type())) {
            address = new LispNonceAddress.Builder()
                                .withNonce(UNIQUE_INT)
                                .withAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(MULTICAST_ADDRESS.type())) {
            address = new LispMulticastAddress.Builder()
                                .withInstanceId(UNIQUE_INT)
                                .withSrcMaskLength(UNIQUE_BYTE)
                                .withSrcAddress(ipv4Addr)
                                .withGrpMaskLength(UNIQUE_BYTE)
                                .withGrpAddress(ipv4Addr)
                                .build();
        }

        if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {

            LispTeAddress.TeRecord tr = new LispTeAddress.TeRecord.Builder()
                                .withIsLookup(UNIQUE_BOOLEAN)
                                .withIsRlocProbe(UNIQUE_BOOLEAN)
                                .withIsStrict(UNIQUE_BOOLEAN)
                                .withRtrRlocAddress(ipv4Addr)
                                .build();

            address = new LispTeAddress.Builder()
                                .withTeRecords(ImmutableList.of(tr))
                                .build();
        }

        if (type.equals(SOURCE_DEST_ADDRESS.type())) {
            address = new LispSrcDstAddress.Builder()
                                .withSrcMaskLength(UNIQUE_BYTE)
                                .withSrcPrefix(ipv4Addr)
                                .withDstMaskLength(UNIQUE_BYTE)
                                .withDstPrefix(ipv4Addr)
                                .build();
        }
        return address;
    }
}