/*
 * 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.
 */

#include <rp_secpolicy_builder.h>
#include <neethi_operator.h>
#include <neethi_exactlyone.h>
#include <neethi_all.h>
#include <neethi_engine.h>
#include <neethi_assertion.h>

/*private functions*/

axis2_status_t AXIS2_CALL
secpolicy_process_alternatives(
    const axutil_env_t *env,
    neethi_all_t *all,
    rp_secpolicy_t *secpolicy);

/***********************************/

AXIS2_EXTERN rp_secpolicy_t *AXIS2_CALL
rp_secpolicy_builder_build(
    const axutil_env_t *env,
    neethi_policy_t *policy)
{
    axutil_array_list_t *alternatives = NULL;
    neethi_operator_t *component = NULL;
    neethi_all_t *all = NULL;
    rp_secpolicy_t *secpolicy = NULL;

    secpolicy = rp_secpolicy_create(env);

    alternatives = neethi_policy_get_alternatives(policy, env);

    component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
    all = (neethi_all_t *)neethi_operator_get_value(component, env);

    if(secpolicy_process_alternatives(env, all, secpolicy) == AXIS2_FAILURE)
    {
        return NULL;
    }
    return secpolicy;
}

axis2_status_t AXIS2_CALL
secpolicy_process_alternatives(
    const axutil_env_t *env,
    neethi_all_t *all,
    rp_secpolicy_t *secpolicy)
{

    neethi_operator_t *operator = NULL;
    axutil_array_list_t *arraylist = NULL;
    neethi_assertion_t *assertion = NULL;
    neethi_assertion_type_t type;
    void *value = NULL;

    int i = 0;

    arraylist = neethi_all_get_policy_components(all, env);

    for(i = 0; i < axutil_array_list_size(arraylist, env); i++)
    {
        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
        value = neethi_assertion_get_value(assertion, env);
        type = neethi_assertion_get_type(assertion, env);

        if(value)
        {
            if(type == ASSERTION_TYPE_TRANSPORT_BINDING)
            {
                rp_property_t *binding = NULL;
                rp_transport_binding_t *transport_binding = NULL;

                transport_binding = (rp_transport_binding_t *)neethi_assertion_get_value(assertion,
                    env);
                if(!transport_binding)
                {
                    return AXIS2_FAILURE;
                }
                binding = rp_property_create(env);
                rp_property_set_value(binding, env, transport_binding,
                    RP_PROPERTY_TRANSPORT_BINDING);
                rp_secpolicy_set_binding(secpolicy, env, binding);
            }
            else if(type == ASSERTION_TYPE_ASSYMMETRIC_BINDING)
            {
                rp_property_t *binding = NULL;
                rp_asymmetric_binding_t *asymmetric_binding = NULL;

                asymmetric_binding = (rp_asymmetric_binding_t *)neethi_assertion_get_value(
                    assertion, env);
                if(!asymmetric_binding)
                {
                    return AXIS2_FAILURE;
                }
                binding = rp_property_create(env);
                rp_property_set_value(binding, env, asymmetric_binding,
                    RP_PROPERTY_ASYMMETRIC_BINDING);
                rp_secpolicy_set_binding(secpolicy, env, binding);
            }
            else if(type == ASSERTION_TYPE_SYMMETRIC_BINDING)
            {
                rp_property_t *binding = NULL;
                rp_symmetric_binding_t *symmetric_binding = NULL;

                symmetric_binding = (rp_symmetric_binding_t *)neethi_assertion_get_value(assertion,
                    env);
                if(!symmetric_binding)
                {
                    return AXIS2_FAILURE;
                }
                binding = rp_property_create(env);
                rp_property_set_value(binding, env, symmetric_binding,
                    RP_PROPERTY_SYMMETRIC_BINDING);
                rp_secpolicy_set_binding(secpolicy, env, binding);
            }
            else if(type == ASSERTION_TYPE_SUPPORTING_TOKENS)
            {
                rp_supporting_tokens_t *supporting_tokens = NULL;
                supporting_tokens = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion,
                    env);
                if(supporting_tokens)
                {
                    rp_property_type_t type;
                    type = rp_supporting_tokens_get_type(supporting_tokens, env);
                    if(type == RP_PROPERTY_SIGNED_SUPPORTING_TOKEN)
                    {
                        rp_secpolicy_set_signed_supporting_tokens(secpolicy, env, supporting_tokens);
                    }
                    else if(type == RP_PROPERTY_SIGNED_ENDORSING_SUPPORTING_TOKEN)
                    {
                        rp_secpolicy_set_signed_endorsing_supporting_tokens(secpolicy, env,
                            supporting_tokens);
                    }
                    else if(type == RP_PROPERTY_SUPPORTING_SUPPORTING_TOKEN)
                    {
                        rp_secpolicy_set_supporting_tokens(secpolicy, env, supporting_tokens);
                    }
                    else if(type == RP_PROPERTY_ENDORSING_SUPPORTING_TOKEN)
                    {
                        rp_secpolicy_set_endorsing_supporting_tokens(secpolicy, env,
                            supporting_tokens);
                    }
                    else
                        return AXIS2_FAILURE;
                }
                else
                    return AXIS2_FAILURE;
            }
            else if(type == ASSERTION_TYPE_WSS10)
            {
                rp_wss10_t *wss10 = NULL;
                rp_property_t *wss = NULL;
                wss10 = (rp_wss10_t *)neethi_assertion_get_value(assertion, env);
                if(!wss10)
                {
                    return AXIS2_FAILURE;
                }
                wss = rp_property_create(env);
                rp_property_set_value(wss, env, wss10, RP_PROPERTY_WSS10);
                rp_secpolicy_set_wss(secpolicy, env, wss);
            }
            else if(type == ASSERTION_TYPE_WSS11)
            {
                rp_wss11_t *wss11 = NULL;
                rp_property_t *wss = NULL;
                wss11 = (rp_wss11_t *)neethi_assertion_get_value(assertion, env);
                if(!wss11)
                {
                    return AXIS2_FAILURE;
                }
                wss = rp_property_create(env);
                rp_property_set_value(wss, env, wss11, RP_PROPERTY_WSS11);
                rp_secpolicy_set_wss(secpolicy, env, wss);
            }
            else if(type == ASSERTION_TYPE_TRUST10)
            {
                rp_trust10_t *trust10 = NULL;
                trust10 = (rp_trust10_t *)neethi_assertion_get_value(assertion, env);
                if(!trust10)
                {
                    return AXIS2_FAILURE;
                }
                rp_secpolicy_set_trust10(secpolicy, env, trust10);
            }
            else if(type == ASSERTION_TYPE_SIGNED_ENCRYPTED_PARTS)
            {
                rp_signed_encrypted_parts_t *signed_encrypted_parts = NULL;
                signed_encrypted_parts = (rp_signed_encrypted_parts_t *)neethi_assertion_get_value(
                    assertion, env);
                if(signed_encrypted_parts)
                {
                    if(rp_signed_encrypted_parts_get_signedparts(signed_encrypted_parts, env))
                    {
                        rp_secpolicy_set_signed_parts(secpolicy, env, signed_encrypted_parts);
                    }
                    else
                    {
                        rp_secpolicy_set_encrypted_parts(secpolicy, env, signed_encrypted_parts);
                    }
                }
                else
                    return AXIS2_FAILURE;

            }
            else if(type == ASSERTION_TYPE_RAMPART_CONFIG)
            {
                rp_rampart_config_t *rampart_config = NULL;
                rampart_config = (rp_rampart_config_t *)neethi_assertion_get_value(assertion, env);
                if(!rampart_config)
                {
                    return AXIS2_FAILURE;
                }
                rp_secpolicy_set_rampart_config(secpolicy, env, rampart_config);
            }
            else
            {
                continue;
            }
        }
        else
            return AXIS2_FAILURE;
    }
    return AXIS2_SUCCESS;
}