/*
 *  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.yoko.orb.OCI.IIOP;

import org.apache.yoko.orb.CORBA.InputStream;
import org.apache.yoko.orb.CORBA.OutputStream;
import org.omg.CORBA.Any;
import org.omg.CSIIOP.CompoundSecMechList;
import org.omg.CSIIOP.CompoundSecMechListHelper;
import org.omg.CSIIOP.TAG_TLS_SEC_TRANS;
import org.omg.CSIIOP.TLS_SEC_TRANS;
import org.omg.CSIIOP.TLS_SEC_TRANSHelper;
import org.omg.CSIIOP.TransportAddress;
import org.omg.IOP.Codec;
import org.omg.IOP.CodecPackage.FormatMismatch;
import org.omg.IOP.CodecPackage.TypeMismatch;

final public class Util {
    static public org.omg.IOP.IOR createIOR(String host, int port, String id,
            org.apache.yoko.orb.OCI.ProfileInfo profileInfo) {
        org.omg.IOP.IOR ior = new org.omg.IOP.IOR();
        ior.type_id = id;
        ior.profiles = new org.omg.IOP.TaggedProfile[1];
        ior.profiles[0] = new org.omg.IOP.TaggedProfile();
        ior.profiles[0].tag = org.omg.IOP.TAG_INTERNET_IOP.value;

        if (profileInfo.major == 1 && profileInfo.minor == 0) {
            org.omg.IIOP.ProfileBody_1_0 body = new org.omg.IIOP.ProfileBody_1_0();
            body.iiop_version = new org.omg.IIOP.Version((byte) 1, (byte) 0);
            body.host = host;
            if (port >= 0x8000)
                body.port = (short) (port - 0xffff - 1);
            else
                body.port = (short) port;
            body.object_key = profileInfo.key;
            org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer();
            OutputStream out = new OutputStream(buf);
            out._OB_writeEndian();
            org.omg.IIOP.ProfileBody_1_0Helper.write(out, body);
            ior.profiles[0].profile_data = new byte[buf.length()];
            System.arraycopy(buf.data(), 0, ior.profiles[0].profile_data, 0,
                    buf.length());
        } else {
            org.omg.IIOP.ProfileBody_1_1 body = new org.omg.IIOP.ProfileBody_1_1();
            body.iiop_version = new org.omg.IIOP.Version(profileInfo.major,
                    profileInfo.minor);
            body.host = host;
            if (port >= 0x8000)
                body.port = (short) (port - 0xffff - 1);
            else
                body.port = (short) port;
            body.object_key = profileInfo.key;
            body.components = profileInfo.components;
            org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer();
            OutputStream out = new OutputStream(buf);
            out._OB_writeEndian();
            org.omg.IIOP.ProfileBody_1_1Helper.write(out, body);
            ior.profiles[0].profile_data = new byte[buf.length()];
            System.arraycopy(buf.data(), 0, ior.profiles[0].profile_data, 0,
                    buf.length());
        }

        return ior;
    }

    static public org.omg.IOP.IOR createIOR(org.omg.IOP.IOR ior, String id,
            byte[] key) {
        //
        // Extract the IIOP profile information from the provided IOR
        //
        int profile;
        for (profile = 0; profile < ior.profiles.length; profile++)
            if (ior.profiles[profile].tag == org.omg.IOP.TAG_INTERNET_IOP.value)
                break;

        // TODO: Internal error?
        org.apache.yoko.orb.OB.Assert._OB_assert(profile < ior.profiles.length);

        org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                ior.profiles[profile].profile_data,
                ior.profiles[profile].profile_data.length);
        InputStream in = new InputStream(buf, 0, false, null, null);
        in._OB_readEndian();
        org.omg.IIOP.ProfileBody_1_0 body = org.omg.IIOP.ProfileBody_1_0Helper
                .read(in);

        org.apache.yoko.orb.OCI.ProfileInfo profileInfo = new org.apache.yoko.orb.OCI.ProfileInfo();
        profileInfo.key = key;
        profileInfo.major = body.iiop_version.major;
        profileInfo.minor = body.iiop_version.minor;
        profileInfo.components = new org.omg.IOP.TaggedComponent[0];
        return createIOR(body.host, body.port, id, profileInfo);
    }

    static public boolean extractProfileInfo(org.omg.IOP.IOR ior,
            org.apache.yoko.orb.OCI.ProfileInfoHolder profileInfo) {
        org.apache.yoko.orb.OCI.ProfileInfoSeqHolder profileInfoSeq = new org.apache.yoko.orb.OCI.ProfileInfoSeqHolder();
        profileInfoSeq.value = new org.apache.yoko.orb.OCI.ProfileInfo[0];
        extractAllProfileInfos(ior, profileInfoSeq, false, null, 0, false, null);
        if (profileInfoSeq.value.length > 0) {
            profileInfo.value = profileInfoSeq.value[0];
            return true;
        }

        return false;
    }

    static public boolean hostMatch(String host1, String host2,
            boolean loopbackMatches) {
        //
        // Direct host name comparison
        //
        if (!host1.equals(host2)) {
            //
            //
            // Direct host name comparision failed - must look up
            // addresses to be really sure if the hosts differ
            //
            try {
                java.net.InetAddress addr1 = java.net.InetAddress
                        .getByName(host1);

                java.net.InetAddress addr2 = java.net.InetAddress
                        .getByName(host2);

                if (!addr1.equals(addr2)) {
                    //
                    // Address comparison failed - shall I extract
                    // the key if the profile body contains the
                    // loopback address?
                    //
                    if (loopbackMatches) {
                        java.net.InetAddress loopback = java.net.InetAddress
                                .getByName("127.0.0.1");

                        if (!addr2.equals(loopback))
                            return false;
                    } else
                        return false;
                }
            } catch (java.net.UnknownHostException ex) {
                //
                // Continue on hostname lookup failure
                //
                return false;
            }
        }

        return true;
    }

    static public void extractAllProfileInfos(org.omg.IOP.IOR ior,
            org.apache.yoko.orb.OCI.ProfileInfoSeqHolder profileInfoSeq,
            boolean performMatch, String host, int port, boolean loopbackMatches, Codec codec) {
        short portNo;
        if (port >= 0x8000) {
            portNo = (short) (port - 0xffff - 1);
        }
        else {
            portNo = (short) port;
        }

        java.util.Vector vec = new java.util.Vector();
        for (int i = 0; i < ior.profiles.length; i++) {
            if (ior.profiles[i].tag == org.omg.IOP.TAG_INTERNET_IOP.value) {
                //
                // Get the IIOP profile body
                //
                byte[] data = ior.profiles[i].profile_data;
                org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                        data, data.length);
                InputStream in = new InputStream(buf, 0, false, null, null);
                in._OB_readEndian();
                org.omg.IIOP.ProfileBody_1_0 body = org.omg.IIOP.ProfileBody_1_0Helper
                        .read(in);

                //
                // Read components if the IIOP version is > 1.0
                //
                org.omg.IOP.TaggedComponent[] components;
                if (body.iiop_version.major > 1 || body.iiop_version.minor > 0) {
                    int len = in.read_ulong();
                    components = new org.omg.IOP.TaggedComponent[len];
                    for (int j = 0; j < len; j++) {
                        components[j] = org.omg.IOP.TaggedComponentHelper.read(in);
                    }
                } else {
                    components = new org.omg.IOP.TaggedComponent[0];
                }

                if (performMatch) {
                    //
                    // Check primary host/port
                    //
                    boolean match = false;
                    if (portNo == body.port
                            && hostMatch(host, body.host, loopbackMatches)) {
                        match = true;
                    }

                    //
                    // Check alternate host/port
                    //
                    if (!match) {
                        for (int j = 0; j < components.length && !match; j++) {
                            if (components[j].tag == org.omg.IOP.TAG_ALTERNATE_IIOP_ADDRESS.value) {
                                byte[] d = components[j].component_data;
                                org.apache.yoko.orb.OCI.Buffer b = new org.apache.yoko.orb.OCI.Buffer(
                                        d, d.length);
                                InputStream s = new InputStream(b, 0, false,
                                        null, null);
                                s._OB_readEndian();
                                String altHost = s.read_string();
                                short altPort = s.read_ushort();
                                if (portNo == altPort
                                        && hostMatch(host, altHost,
                                                loopbackMatches)) {
                                    match = true;
                                }
                            } else if (components[j].tag == org.omg.CSIIOP.TAG_CSI_SEC_MECH_LIST.value) {
                                Any any;
                                try {
                                    any = codec.decode_value(components[j].component_data, CompoundSecMechListHelper.type());
                                    CompoundSecMechList csml = CompoundSecMechListHelper.extract(any);

                                    for (int k = 0; i < csml.mechanism_list.length && !match; i++) {
                                        org.omg.IOP.TaggedComponent tc = csml.mechanism_list[k].transport_mech;
                                        if (tc.tag == TAG_TLS_SEC_TRANS.value) {
                                            Any tstAny = codec.decode_value(tc.component_data, TLS_SEC_TRANSHelper.type());
                                            TLS_SEC_TRANS tst = TLS_SEC_TRANSHelper.extract(tstAny);
                                            TransportAddress[] transportAddresses = tst.addresses;
                                            for (TransportAddress addr: transportAddresses) {
                                                if (portNo == addr.port && hostMatch(host, addr.host_name, loopbackMatches)) {
                                                    match = true;
                                                    break;
                                                }
                                            }

                                        }
                                    }

                                } catch (FormatMismatch e) {
                                } catch (TypeMismatch e) {
                                }
                            }
                        }
                    }

                    if (!match)
                        continue;
                }

                //
                // OK, found a match
                //
                org.apache.yoko.orb.OCI.ProfileInfo profileInfo = new org.apache.yoko.orb.OCI.ProfileInfo();
                profileInfo.key = body.object_key;
                profileInfo.minor = body.iiop_version.minor;
                profileInfo.major = body.iiop_version.major;
                profileInfo.id = ior.profiles[i].tag;
                profileInfo.index = i;
                profileInfo.components = components;

                vec.addElement(profileInfo);
            }
        }

        if (vec.size() > 0) {
            int len = profileInfoSeq.value.length;
            if (len == 0) {
                profileInfoSeq.value = new org.apache.yoko.orb.OCI.ProfileInfo[vec
                        .size()];
                vec.copyInto(profileInfoSeq.value);
            } else {
                org.apache.yoko.orb.OCI.ProfileInfo[] arr = new org.apache.yoko.orb.OCI.ProfileInfo[len
                        + vec.size()];
                System.arraycopy(profileInfoSeq.value, 0, arr, 0, len);
                for (int i = 0; i < vec.size(); i++) {
                    arr[len + i] = (org.apache.yoko.orb.OCI.ProfileInfo) vec.elementAt(i);
                }
                profileInfoSeq.value = arr;
            }
        }
    }

    static public boolean equivalent(org.omg.IOP.IOR ior1, org.omg.IOP.IOR ior2) {
        int p1, p2, b1, b2;
        int cnt1 = 0, cnt2 = 0;
        org.omg.IIOP.ProfileBody_1_0[] bodies1;
        org.omg.IIOP.ProfileBody_1_0[] bodies2;

        //
        // Calculate number of IIOP profiles in ior1
        //
        for (p1 = 0; p1 < ior1.profiles.length; p1++)
            if (ior1.profiles[p1].tag == org.omg.IOP.TAG_INTERNET_IOP.value)
                cnt1++;

        //
        // Calculate number of IIOP profiles in ior2
        //
        for (p2 = 0; p2 < ior2.profiles.length; p2++)
            if (ior2.profiles[p2].tag == org.omg.IOP.TAG_INTERNET_IOP.value)
                cnt2++;

        //
        // Return false now if the number of IIOP profile bodies do not
        // match
        //
        if (cnt1 != cnt2)
            return false;

        //
        // Create an array with all IIOP profile bodies of ior1
        //
        bodies1 = new org.omg.IIOP.ProfileBody_1_0[cnt1];
        for (p1 = 0, b1 = 0; p1 < ior1.profiles.length; p1++)
            if (ior1.profiles[p1].tag == org.omg.IOP.TAG_INTERNET_IOP.value) {
                byte[] data = ior1.profiles[p1].profile_data;
                org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                        data, data.length);
                InputStream in = new InputStream(buf, 0, false, null, null);
                in._OB_readEndian();
                bodies1[b1++] = org.omg.IIOP.ProfileBody_1_0Helper.read(in);
            }

        if (b1 != cnt1)
            throw new InternalError();

        //
        // Create an array with all IIOP profile bodies of ior2
        //
        bodies2 = new org.omg.IIOP.ProfileBody_1_0[cnt2];
        for (p2 = 0, b2 = 0; p2 < ior2.profiles.length; p2++)
            if (ior2.profiles[p2].tag == org.omg.IOP.TAG_INTERNET_IOP.value) {
                byte[] data = ior2.profiles[p2].profile_data;
                org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                        data, data.length);
                InputStream in = new InputStream(buf, 0, false, null, null);
                in._OB_readEndian();
                bodies2[b2++] = org.omg.IIOP.ProfileBody_1_0Helper.read(in);
            }

        if (b2 != cnt2)
            throw new InternalError();

        //
        // Check for profile body matches
        //
        for (b1 = 0; b1 < cnt1; b1++) {
            for (b2 = 0; b2 < cnt2; b2++) {
                if (bodies2[b2] == null)
                    continue;

                //
                // Compare profile bodies
                //
                if (compareBodies(bodies1[b1], bodies2[b2])) {
                    //
                    // OK, found a match
                    //
                    bodies1[b1] = null;
                    bodies2[b2] = null;
                    break;
                }
            }
        }

        //
        // Check whether there are any unmatched IIOP profile bodies
        //
        for (b1 = 0; b1 < cnt1; b1++)
            if (bodies1[b1] != null)
                return false;

        for (b2 = 0; b2 < cnt2; b2++)
            if (bodies2[b2] != null)
                return false;

        return true;
    }

    static boolean compareBodies(org.omg.IIOP.ProfileBody_1_0 body1,
            org.omg.IIOP.ProfileBody_1_0 body2) {
        //
        // Compare versions
        //
        if (body1.iiop_version.major != body2.iiop_version.major
                || body1.iiop_version.minor != body2.iiop_version.minor)
            return false;

        //
        // Compare ports
        //
        if (body1.port != body2.port)
            return false;

        //
        // Compare object keys
        //
        if (body1.object_key.length != body2.object_key.length)
            return false;

        int k;
        for (k = 0; k < body1.object_key.length; k++)
            if (body1.object_key[k] != body2.object_key[k])
                return false;

        //
        // Direct host name comparison
        //
        if (!body1.host.equals(body2.host)) {
            //
            // Direct host name comparision failed - must look up
            // addresses to be really sure if the hosts differ
            //
            try {
                java.net.InetAddress addr1 = java.net.InetAddress
                        .getByName(body1.host);

                java.net.InetAddress addr2 = java.net.InetAddress
                        .getByName(body2.host);

                if (!addr1.equals(addr2))
                    return false;
            } catch (java.net.UnknownHostException ex) {
                //
                // Return false on hostname lookup failure
                //
                return false;
            }
        }

        //
        // OK, found a match
        //
        return true;
    }

    //
    // Calculate a hash for an IOR containing IIOP profiles
    //
    static public int hash(org.omg.IOP.IOR ior, int maximum) {
        int hash = 0;

        for (int i = 0; i < ior.profiles.length; i++) {
            if (ior.profiles[i].tag == org.omg.IOP.TAG_INTERNET_IOP.value) {
                //
                // Get the first IIOP profile body
                //
                byte[] data = ior.profiles[i].profile_data;
                org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                        data, data.length);
                InputStream in = new InputStream(buf, 0, false, null, null);
                in._OB_readEndian();
                org.omg.IIOP.ProfileBody_1_0 body = org.omg.IIOP.ProfileBody_1_0Helper
                        .read(in);

                //
                // Add port to hash
                //
                hash ^= body.port;

                //
                // Add object key to hash
                //
                for (int j = 0; j + 1 < body.object_key.length; j += 2)
                    hash ^= body.object_key[j + 1] * 256 + body.object_key[j];
            }
        }

        return hash % (maximum + 1);
    }
}