// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.apache.cloudstack.network.contrail.model;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.juniper.contrail.api.ApiConnector;
import net.juniper.contrail.api.ObjectReference;
import net.juniper.contrail.api.types.NetworkIpam;
import net.juniper.contrail.api.types.Project;
import net.juniper.contrail.api.types.SubnetType;
import net.juniper.contrail.api.types.VirtualNetwork;
import net.juniper.contrail.api.types.VnSubnetsType;

import org.apache.log4j.Logger;

import org.apache.cloudstack.network.contrail.management.ContrailManager;

import com.cloud.dc.VlanVO;
import com.cloud.dc.dao.VlanDao;
import com.cloud.exception.InternalErrorException;
import com.cloud.network.Network;
import com.cloud.network.Networks.TrafficType;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.net.NetUtils;

public class VirtualNetworkModel extends ModelObjectBase {
    private static final Logger s_logger = Logger.getLogger(VirtualNetworkModel.class);

    private String _uuid;
    private long _id;
    private TrafficType _trafficType;

    /*
     * current state for object properties
     */
    private boolean _initialized;
    private String _name;
    private String _prefix;
    private String _gateway;
    private String _projectId;

    /*
     * cached API server objects
     */
    private VirtualNetwork _vn;
    private NetworkIpam _ipam;

    private FloatingIpPoolModel _fipPoolModel;

    public VirtualNetworkModel(Network network, String uuid, String name, TrafficType trafficType) {
        _uuid = uuid;
        _name = name;
        _trafficType = trafficType;
        if (network != null) {
            _id = network.getId();
        }

        if (isDynamicNetwork()) {
            assert _uuid != null : "uuid is must for dynamic networks";
        } else {
            assert _name != null : "name is must for static networks";
        }
    }

    /*
     * Resynchronize internal state from the cloudstack DB object.
     */
    public void build(ModelController controller, Network network) {
        setProperties(controller, network);
    }

    /**
     * Determine whether this network is dynamically created by cloudstack or is created by default by the contrail
     * API server.
     *
     * @return
     */
    boolean isDynamicNetwork() {
        return (_trafficType == TrafficType.Guest) || (_trafficType == TrafficType.Public);
    }

    @Override
    public int compareTo(ModelObject o) {
        VirtualNetworkModel other;
        try {
            other = (VirtualNetworkModel)o;
        } catch (ClassCastException ex) {
            String clsname = o.getClass().getName();
            return VirtualNetworkModel.class.getName().compareTo(clsname);
        }

        if (!isDynamicNetwork()) {
            if (!other.isDynamicNetwork()) {
                // name is not unique since both management and storage networks may map to ip-fabric
                int cmp = _name.compareTo(other.getName());
                if (cmp != 0) {
                    return cmp;
                }
                return _trafficType.compareTo(other._trafficType);
            }
            return -1;
        } else if (!other.isDynamicNetwork()) {
            return 1;
        }

        return _uuid.compareTo(other._uuid);
    }

    @Override
    public void delete(ModelController controller) throws IOException {
        ApiConnector api = controller.getApiAccessor();
        for (ModelObject successor : successors()) {
            successor.delete(controller);
        }

        try {
            api.delete(VirtualNetwork.class, _uuid);
        } catch (IOException ex) {
            s_logger.warn("virtual-network delete", ex);
        }
    }

    @Override
    public void destroy(ModelController controller) throws IOException {
        delete(controller);

        for (ModelObject successor : successors()) {
            successor.destroy(controller);
        }
        clearSuccessors();
    }

    public String getName() {
        return _name;
    }

    public String getUuid() {
        return _uuid;
    }

    public VirtualNetwork getVirtualNetwork() {
        return _vn;
    }

    /**
     * Initialize the object properties based on the DB object.
     * Common code between plugin calls and DBSync.
     */
    public void setProperties(ModelController controller, Network network) {
        ContrailManager manager = controller.getManager();
        _name = manager.getCanonicalName(network);
        _prefix = network.getCidr();
        _gateway = network.getGateway();

        // For non-cloudstack managed network, find the uuid at this stage.
        if (!isDynamicNetwork()) {
            try {
                _uuid = manager.findVirtualNetworkId(network);
            } catch (IOException ex) {
                s_logger.warn("Unable to read virtual-network", ex);
            }
        }

        try {
            _projectId = manager.getProjectId(network.getDomainId(), network.getAccountId());
        } catch (IOException ex) {
            s_logger.warn("project read", ex);
            throw new CloudRuntimeException(ex);
        }

        _initialized = true;
    }

    @Override
    public void update(ModelController controller) throws InternalErrorException, IOException {

        assert _initialized;

        ApiConnector api = controller.getApiAccessor();
        VlanDao vlanDao = controller.getVlanDao();
        VirtualNetwork vn = _vn;

        if (!isDynamicNetwork()) {
            _vn = (VirtualNetwork)controller.getApiAccessor().findById(VirtualNetwork.class, _uuid);
            return;
        }

        assert _uuid != null : "uuid is not set";

        if (_vn == null) {
            vn = _vn = (VirtualNetwork)controller.getApiAccessor().findById(VirtualNetwork.class, _uuid);
            if (vn == null) {
                vn = new VirtualNetwork();
                if (_projectId != null) {
                    Project project;
                    try {
                        project = (Project)api.findById(Project.class, _projectId);
                    } catch (IOException ex) {
                        s_logger.debug("project read", ex);
                        throw new CloudRuntimeException("Failed to read project", ex);
                    }
                    vn.setParent(project);
                }
                vn.setName(_name);
                vn.setUuid(_uuid);
            }
        }

        if (_ipam == null) {
            NetworkIpam ipam = null;
            try {
                String ipam_id = api.findByName(NetworkIpam.class, null, "default-network-ipam");
                if (ipam_id == null) {
                    s_logger.debug("could not find default-network-ipam");
                    return;
                }
                ipam = (NetworkIpam)api.findById(NetworkIpam.class, ipam_id);
                if (ipam == null) {
                    s_logger.debug("could not find NetworkIpam with ipam_id: " + ipam_id);
                    return;
                }
            } catch (IOException ex) {
                s_logger.error(ex);
                return;
            }
            _ipam = ipam;
        }

        if (_prefix != null) {
            VnSubnetsType subnet = new VnSubnetsType();
            String[] addr_pair = _prefix.split("\\/");
            subnet.addIpamSubnets(new SubnetType(addr_pair[0], Integer.parseInt(addr_pair[1])), _gateway);
            vn.setNetworkIpam(_ipam, subnet);
        } else if (_trafficType == TrafficType.Public) {
            vn.clearNetworkIpam();
            /* Subnet information for Public is stored in the vlan table */
            List<VlanVO> vlan_list = vlanDao.listVlansByNetworkId(_id);
            for (VlanVO vlan : vlan_list) {
                String cidr = NetUtils.ipAndNetMaskToCidr(vlan.getVlanGateway(), vlan.getVlanNetmask());
                int slash = cidr.indexOf('/');
                String ip_addr = cidr.substring(0, slash);
                int plen = Integer.parseInt(cidr.substring(slash + 1));
                VnSubnetsType subnet = new VnSubnetsType();
                subnet.addIpamSubnets(new SubnetType(ip_addr, plen), vlan.getVlanGateway());
                vn.addNetworkIpam(_ipam, subnet);
            }
        }

        if (_vn == null) {
            try {
                api.create(vn);
            } catch (Exception ex) {
                s_logger.debug("virtual-network create", ex);
                throw new CloudRuntimeException("Failed to create virtual-network", ex);
            }
            _vn = vn;
        } else {
            try {
                api.update(vn);
            } catch (IOException ex) {
                s_logger.warn("virtual-network update", ex);
                throw new CloudRuntimeException("Unable to update virtual-network object", ex);
            }
        }

        for (ModelObject successor : successors()) {
            successor.update(controller);
        }
    }

    public void read(ModelController controller) {
        ApiConnector api = controller.getApiAccessor();
        VlanDao vlanDao = controller.getVlanDao();
        try {
            _vn = (VirtualNetwork)api.findById(VirtualNetwork.class, _uuid);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (_vn == null) {
            return;
        }
        if (_ipam == null) {
            NetworkIpam ipam = null;
            try {
                String ipam_id = api.findByName(NetworkIpam.class, null, "default-network-ipam");
                if (ipam_id == null) {
                    s_logger.debug("could not find default-network-ipam");
                    return;
                }
                ipam = (NetworkIpam)api.findById(NetworkIpam.class, ipam_id);
                if (ipam == null) {
                    s_logger.debug("could not find NetworkIpam with ipam_id: " + ipam_id);
                    return;
                }
            } catch (IOException ex) {
                s_logger.error(ex);
                return;
            }
            _ipam = ipam;
        }

        if (_prefix != null) {
            VnSubnetsType subnet = new VnSubnetsType();
            String[] addr_pair = _prefix.split("\\/");
            subnet.addIpamSubnets(new SubnetType(addr_pair[0], Integer.parseInt(addr_pair[1])), _gateway);
            _vn.setNetworkIpam(_ipam, subnet);
        } else if (_trafficType == TrafficType.Public) {
            _vn.clearNetworkIpam();
            /* Subnet information for Public is stored in the vlan table */
            List<VlanVO> vlan_list = vlanDao.listVlansByNetworkId(_id);
            for (VlanVO vlan : vlan_list) {
                String cidr = NetUtils.ipAndNetMaskToCidr(vlan.getVlanGateway(), vlan.getVlanNetmask());
                int slash = cidr.indexOf('/');
                String ip_addr = cidr.substring(0, slash);
                int plen = Integer.parseInt(cidr.substring(slash + 1));
                VnSubnetsType subnet = new VnSubnetsType();
                subnet.addIpamSubnets(new SubnetType(ip_addr, plen), vlan.getVlanGateway());
                _vn.addNetworkIpam(_ipam, subnet);
            }
        }
        return;
    }

    @Override
    public boolean verify(ModelController controller) {
        assert _initialized : "initialized is false";
        assert _uuid != null : "uuid is not set";

        ApiConnector api = controller.getApiAccessor();
        VlanDao vlanDao = controller.getVlanDao();

        try {
            _vn = (VirtualNetwork)api.findById(VirtualNetwork.class, _uuid);
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (_vn == null) {
            return false;
        }

        if (!isDynamicNetwork()) {
            return true;
        }

        List<String> dbSubnets = new ArrayList<String>();
        if (_trafficType == TrafficType.Public) {
            List<VlanVO> vlan_list = vlanDao.listVlansByNetworkId(_id);
            for (VlanVO vlan : vlan_list) {
                String cidr = NetUtils.ipAndNetMaskToCidr(vlan.getVlanGateway(), vlan.getVlanNetmask());
                dbSubnets.add(vlan.getVlanGateway() + cidr);
            }
        } else {
            dbSubnets.add(this._gateway + this._prefix);
        }

        List<ObjectReference<VnSubnetsType>> ipamRefs = _vn.getNetworkIpam();
        List<String> vncSubnets = new ArrayList<String>();

        if (ipamRefs == null && !dbSubnets.isEmpty()) {
            return false;
        }

        if (ipamRefs != null) {
            for (ObjectReference<VnSubnetsType> ref : ipamRefs) {
                VnSubnetsType vnSubnetType = ref.getAttr();
                if (vnSubnetType != null) {
                    List<VnSubnetsType.IpamSubnetType> subnets = vnSubnetType.getIpamSubnets();
                    if (subnets != null && !subnets.isEmpty()) {
                        VnSubnetsType.IpamSubnetType ipamSubnet = subnets.get(0);
                        vncSubnets.add(ipamSubnet.getDefaultGateway() + ipamSubnet.getSubnet().getIpPrefix() + "/" + ipamSubnet.getSubnet().getIpPrefixLen());
                    }
                }
            }
        }
        // unordered, no duplicates hence perform negation operation as set
        Set<String> diff = new HashSet<String>(dbSubnets);
        diff.removeAll(vncSubnets);

        if (!diff.isEmpty()) {
            s_logger.debug("Subnets changed, network: " + this._name + "; db: " + dbSubnets + ", vnc: " + vncSubnets + ", diff: " + diff);
            return false;
        }

        for (ModelObject successor : successors()) {
            if (!successor.verify(controller)) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean compare(ModelController controller, ModelObject o) {
        VirtualNetworkModel latest;
        ApiConnector api = controller.getApiAccessor();

        assert this._vn != null : "vnc virtual network current is not initialized";

        try {
            latest = (VirtualNetworkModel)o;
        } catch (ClassCastException ex) {
            s_logger.warn("Invalid model object is passed to cast to VirtualNetworkModel");
            return false;
        }

        try {
            latest.read(controller);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        assert latest._vn != null : "vnc virtual network new is not initialized";

        List<ObjectReference<VnSubnetsType>> currentIpamRefs = this._vn.getNetworkIpam();
        List<ObjectReference<VnSubnetsType>> newIpamRefs = latest._vn.getNetworkIpam();
        List<String> currentSubnets = new ArrayList<String>();
        List<String> newSubnets = new ArrayList<String>();

        if ((currentIpamRefs == null && newIpamRefs != null) || (currentIpamRefs != null && newIpamRefs == null)) {  //Check for existence only
            s_logger.debug("ipams differ: current=" + currentIpamRefs + ", new=" + newIpamRefs);
            return false;
        }
        if (currentIpamRefs == null) {
            return true;
        }

        for (ObjectReference<VnSubnetsType> ref : currentIpamRefs) {
            VnSubnetsType vnSubnetType = ref.getAttr();
            if (vnSubnetType != null) {
                List<VnSubnetsType.IpamSubnetType> subnets = vnSubnetType.getIpamSubnets();
                if (subnets != null && !subnets.isEmpty()) {
                    VnSubnetsType.IpamSubnetType ipamSubnet = subnets.get(0);
                    currentSubnets.add(ipamSubnet.getDefaultGateway() + ipamSubnet.getSubnet().getIpPrefix() + "/" + ipamSubnet.getSubnet().getIpPrefixLen());
                }
            }
        }

        for (ObjectReference<VnSubnetsType> ref : newIpamRefs) {
            VnSubnetsType vnSubnetType = ref.getAttr();
            if (vnSubnetType != null) {
                List<VnSubnetsType.IpamSubnetType> subnets = vnSubnetType.getIpamSubnets();
                if (subnets != null && !subnets.isEmpty()) {
                    VnSubnetsType.IpamSubnetType ipamSubnet = subnets.get(0);
                    newSubnets.add(ipamSubnet.getDefaultGateway() + ipamSubnet.getSubnet().getIpPrefix() + "/" + ipamSubnet.getSubnet().getIpPrefixLen());
                }
            }
        }

        Set<String> diff = new HashSet<String>(currentSubnets);
        diff.removeAll(newSubnets);

        if (!diff.isEmpty()) {
            s_logger.debug("Subnets differ, network: " + this._name + "; db: " + currentSubnets + ", vnc: " + newSubnets + ", diff: " + diff);
            return false;
        }

        return true;
    }

    public FloatingIpPoolModel getFipPoolModel() {
        return _fipPoolModel;
    }

    public void setFipPoolModel(FloatingIpPoolModel fipPoolModel) {
        _fipPoolModel = fipPoolModel;
    }
}
