/*
 * 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.provider.lisp.mapping.util;

import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onosproject.lisp.ctl.ExtensionMappingAddressInterpreter;
import org.onosproject.lisp.msg.types.LispAfiAddress;
import org.onosproject.lisp.msg.types.LispAsAddress;
import org.onosproject.lisp.msg.types.LispDistinguishedNameAddress;
import org.onosproject.lisp.msg.types.LispIpv4Address;
import org.onosproject.lisp.msg.types.LispIpv6Address;
import org.onosproject.lisp.msg.types.LispMacAddress;
import org.onosproject.lisp.msg.types.lcaf.LispLcafAddress;
import org.onosproject.mapping.addresses.ExtensionMappingAddress;
import org.onosproject.mapping.addresses.MappingAddress;
import org.onosproject.mapping.addresses.MappingAddresses;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.device.DeviceService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static org.onosproject.mapping.addresses.ExtensionMappingAddressType.ExtensionMappingAddressTypes.*;

/**
 * Mapping address builder class.
 */
public final class MappingAddressBuilder {

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

    private static final int IPV4_PREFIX_LENGTH = 32;
    private static final int IPV6_PREFIX_LENGTH = 128;

    // prevent from instantiation
    private MappingAddressBuilder() {
    }

    /**
     * Converts LispAfiAddress into abstracted mapping address.
     *
     * @param deviceService device service
     * @param deviceId      device identifier
     * @param address       LispAfiAddress
     * @return abstracted mapping address
     */
    protected static MappingAddress getAddress(DeviceService deviceService,
                                               DeviceId deviceId,
                                               LispAfiAddress address) {

        if (address == null) {
            log.warn("Address is not specified.");
            return null;
        }

        switch (address.getAfi()) {
            case IP4:
                return afi2mapping(address);
            case IP6:
                return afi2mapping(address);
            case AS:
                int asNum = ((LispAsAddress) address).getASNum();
                return MappingAddresses.asMappingAddress(String.valueOf(asNum));
            case DISTINGUISHED_NAME:
                String dn = ((LispDistinguishedNameAddress)
                        address).getDistinguishedName();
                return MappingAddresses.dnMappingAddress(dn);
            case MAC:
                MacAddress macAddress = ((LispMacAddress) address).getAddress();
                return MappingAddresses.ethMappingAddress(macAddress);
            case LCAF:
                return deviceService == null ? null :
                        lcaf2extension(deviceService, deviceId, (LispLcafAddress) address);
            default:
                log.warn("Unsupported address type {}", address.getAfi());
                break;
        }

        return null;
    }

    /**
     * Converts AFI address to generalized mapping address.
     *
     * @param afiAddress IP typed AFI address
     * @return generalized mapping address
     */
    private static MappingAddress afi2mapping(LispAfiAddress afiAddress) {
        switch (afiAddress.getAfi()) {
            case IP4:
                IpAddress ipv4Address = ((LispIpv4Address) afiAddress).getAddress();
                IpPrefix ipv4Prefix = IpPrefix.valueOf(ipv4Address, IPV4_PREFIX_LENGTH);
                return MappingAddresses.ipv4MappingAddress(ipv4Prefix);
            case IP6:
                IpAddress ipv6Address = ((LispIpv6Address) afiAddress).getAddress();
                IpPrefix ipv6Prefix = IpPrefix.valueOf(ipv6Address, IPV6_PREFIX_LENGTH);
                return MappingAddresses.ipv6MappingAddress(ipv6Prefix);
            default:
                log.warn("Only support to convert IP address type");
                break;
        }
        return null;
    }

    /**
     * Converts LCAF address to extension mapping address.
     *
     * @param deviceService device service
     * @param deviceId      device identifier
     * @param lcaf          LCAF address
     * @return extension mapping address
     */
    private static MappingAddress lcaf2extension(DeviceService deviceService,
                                                 DeviceId deviceId,
                                                 LispLcafAddress lcaf) {

        Device device = deviceService.getDevice(deviceId);

        ExtensionMappingAddressInterpreter addressInterpreter;
        ExtensionMappingAddress mappingAddress = null;
        if (device.is(ExtensionMappingAddressInterpreter.class)) {
            addressInterpreter = device.as(ExtensionMappingAddressInterpreter.class);
        } else {
            addressInterpreter = null;
        }

        switch (lcaf.getType()) {
            case LIST:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(LIST_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case SEGMENT:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(SEGMENT_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case AS:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(AS_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case APPLICATION_DATA:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(APPLICATION_DATA_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case GEO_COORDINATE:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(GEO_COORDINATE_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case NAT:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(NAT_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case NONCE:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(NONCE_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case MULTICAST:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(MULTICAST_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case TRAFFIC_ENGINEERING:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(TRAFFIC_ENGINEERING_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            case SOURCE_DEST:
                if (addressInterpreter != null &&
                        addressInterpreter.supported(SOURCE_DEST_ADDRESS.type())) {
                    mappingAddress = addressInterpreter.mapLcafAddress(lcaf);
                }
                break;
            default:
                log.warn("Unsupported extension mapping address type {}", lcaf.getType());
                break;
        }

        return mappingAddress != null ?
                MappingAddresses.extensionMappingAddressWrapper(mappingAddress, deviceId) : null;
    }
}