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

struct trust_rstr{

    axis2_char_t *attr_context; /*Context Attribute of RSTR : same as RST context attribute */

    axis2_char_t *token_type;
    
    axis2_char_t *request_type;
    
    axiom_node_t *requested_sec_token;
    
    axis2_char_t *applies_to;
    
    axiom_node_t *requested_attached_ref;
    
    axiom_node_t *requested_unattached_ref;
    
    axiom_node_t *requested_proof_token;
    
    trust_entropy_t *entropy;
    
    trust_life_time_t *life_time;
    
    int key_size;

    axis2_char_t *wst_ns_uri;
    
    /*Use state whether response is going inside soap header or soap body*/
    axis2_bool_t in_header;
};

AXIS2_EXTERN trust_rstr_t * AXIS2_CALL
trust_rstr_create(
        const axutil_env_t *env)
{
    trust_rstr_t *rstr = NULL;
    
    rstr = (trust_rstr_t*)AXIS2_MALLOC(env->allocator, sizeof(trust_rstr_t));
    
    rstr->token_type = NULL;
    rstr->attr_context = NULL;
    rstr->request_type = NULL;
    rstr->requested_sec_token = NULL;
    rstr->applies_to = NULL;
    rstr->requested_attached_ref = NULL;
    rstr->requested_unattached_ref = NULL;
    rstr->requested_proof_token = NULL;
    rstr->entropy = NULL;
    rstr->life_time = NULL;
    rstr->key_size = -1;
    rstr->wst_ns_uri = NULL;
    
    return rstr;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_free(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
	AXIS2_FREE(env->allocator, rstr);
    return AXIS2_SUCCESS;
}


/*Populating RSTR*/

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_populate_rstr(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *rstr_node)
{
    axiom_element_t *rstr_ele = NULL;
    axutil_qname_t *attr_ctx_qname = NULL;
    axis2_char_t *attr_ctx = NULL;
    
    axiom_node_t *requested_security_token_node = NULL;
    axiom_element_t *requested_security_token_ele = NULL;
    axutil_qname_t *requested_security_token_qname = NULL;

    axiom_node_t *proof_token_node = NULL;
    axiom_element_t *proof_token_ele = NULL;
    axutil_qname_t *proof_token_qname = NULL;

    axiom_node_t *attached_reference_node = NULL;
    axiom_element_t *attached_reference_ele = NULL;
    axutil_qname_t *attached_reference_qname = NULL;

    axiom_node_t *unattached_reference_node = NULL;
    axiom_element_t *unattached_reference_ele = NULL;
    axutil_qname_t *unattached_reference_qname = NULL;
    
    axiom_node_t *token_type_node = NULL;
    axiom_element_t *token_type_ele = NULL;
    axutil_qname_t *token_type_qname = NULL;
    axis2_char_t *token_type = NULL;    
    
    axutil_qname_t *applies_to_qname = NULL;
    axiom_node_t *appliesto_node = NULL;
    axiom_element_t *appliesto_ele = NULL;
    axiom_node_t *first_node = NULL;
    axiom_element_t *first_ele = NULL;
    
    
    trust_entropy_t *entropy = NULL;
    axiom_node_t *entropy_node = NULL;
    axiom_element_t *entropy_ele = NULL;
    axutil_qname_t *entropy_qname = NULL;
    
    axiom_node_t *lifetime_node = NULL;
    axiom_element_t *lifetime_ele = NULL;
    axutil_qname_t *lifetime_qname = NULL;
    
    axiom_node_t *key_size_node = NULL;
    axiom_element_t *key_size_ele = NULL;
    axutil_qname_t *key_size_qname = NULL;
    axis2_char_t *key_size = NULL;
    
        
    rstr_ele = (axiom_element_t*)axiom_node_get_data_element(rstr_node, env);
    
    /*@Context RSTR*/
    attr_ctx_qname = axutil_qname_create(env, TRUST_RST_CONTEXT, rstr->wst_ns_uri, TRUST_WST);
    if (!attr_ctx_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Context Attribute Qname creation failed.");
        return AXIS2_FAILURE;
    }
    attr_ctx = axiom_element_get_attribute_value(rstr_ele, env, attr_ctx_qname);
    if (attr_ctx)
    {
        rstr->attr_context = attr_ctx;
    }
	axutil_qname_free(attr_ctx_qname, env);
    
    /*TokenType*/
    token_type_qname = axutil_qname_create(env, TRUST_TOKEN_TYPE, rstr->wst_ns_uri, TRUST_WST);
    if (!token_type_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] TokenType Qname creation failed.");
        return AXIS2_FAILURE;
    }
    token_type_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, token_type_qname, rstr_node, &token_type_node);
    if (token_type_ele)
    {
        token_type = axiom_element_get_text(token_type_ele, env, token_type_node);
        if(token_type)
        {
            rstr->token_type = token_type;
        }        
    }
	axutil_qname_free(token_type_qname, env);
    
    
    /*RequestedSecurityToken*/
    requested_security_token_qname = axutil_qname_create(env, TRUST_REQUESTED_SECURITY_TOKEN, rstr->wst_ns_uri, TRUST_WST);
    if(!requested_security_token_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedSecurityToken Qname creation failed.");
        return AXIS2_FAILURE;
    }
    requested_security_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, requested_security_token_qname, 
                                            rstr_node, &requested_security_token_node);
    if(requested_security_token_ele)
    {
        axiom_element_get_first_element(requested_security_token_ele, env, requested_security_token_node, &rstr->requested_sec_token);
    }
	axutil_qname_free(requested_security_token_qname, env);

	
	/*RequestedProofToken*/
	proof_token_qname = axutil_qname_create(env, TRUST_REQUESTED_PROOF_TOKEN, rstr->wst_ns_uri, TRUST_WST);
	if(!proof_token_qname)
	{
		AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedProofToken Qname creation failed.");
		return AXIS2_FAILURE;
	}
	proof_token_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, proof_token_qname, rstr_node, &proof_token_node);
	if(proof_token_ele)
	{
		axiom_element_get_first_element(proof_token_ele, env, proof_token_node, &rstr->requested_proof_token);
	}
	axutil_qname_free(proof_token_qname, env);
    
    /*AppliesTo*/
    applies_to_qname = axutil_qname_create(env, TRUST_APPLIES_TO, TRUST_WSP_XMLNS, TRUST_WSP);
    if (!applies_to_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Appliesto Qname creation failed.");
        return AXIS2_FAILURE;
    }
    appliesto_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, applies_to_qname, rstr_node, &appliesto_node);
    if(appliesto_ele)
    {
        first_ele = axiom_element_get_first_element(appliesto_ele, env, appliesto_node, &first_node);
        if(first_ele)
        {
            rstr->applies_to = axiom_element_get_text(first_ele, env, first_node);
        }
    }
	axutil_qname_free(applies_to_qname, env);
    
    /*Entropy*/
    entropy_qname = axutil_qname_create(env, TRUST_ENTROPY, rstr->wst_ns_uri, TRUST_WST);
    if (!entropy_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] Entropy Qname creation failed.");
        return AXIS2_FAILURE;
    }
    entropy_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, entropy_qname, rstr_node, &entropy_node);
    if(entropy_ele)
    {
        entropy = trust_entropy_create(env);
        trust_entropy_set_ns_uri(entropy, env, rstr->wst_ns_uri);
        if(AXIS2_SUCCESS == trust_entropy_deserialize(entropy, env, entropy_node))
        {
            rstr->entropy = entropy;
        }
    }
	axutil_qname_free(entropy_qname, env);
    
    
    /*LifeTime*/
    lifetime_qname = axutil_qname_create(env, TRUST_LIFE_TIME, rstr->wst_ns_uri, TRUST_WST);
    if(!lifetime_qname)
    {
        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] LifeTime Qname creation failed.");
        return AXIS2_FAILURE;        
    }
    lifetime_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, lifetime_qname, rstr_node, &lifetime_node);
    if(lifetime_ele)
    {
        rstr->life_time = trust_life_time_create(env);
        if(AXIS2_SUCCESS == trust_life_time_deserialize(rstr->life_time, env, lifetime_node))
        {
            
        }
    }
    axutil_qname_free(lifetime_qname, env);

        /* KeySize */
    key_size_qname = axutil_qname_create(env, TRUST_KEY_SIZE, rstr->wst_ns_uri, TRUST_WST);
    key_size_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, key_size_qname, rstr_node, &key_size_node);
    if(key_size_ele)
    {
        key_size = axiom_element_get_text(key_size_ele, env, key_size_node);
        if(key_size)
        {
            rstr->key_size = atoi(key_size);
        }
    }
	axutil_qname_free(key_size_qname, env);

    /*Attached reference*/
	attached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_ATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
	if(!attached_reference_qname)
	{
		AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedAttachedReference Qname creation failed.");
		return AXIS2_FAILURE;
	}
	attached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, attached_reference_qname, rstr_node, &attached_reference_node);
	if(attached_reference_ele)
	{
		axiom_element_get_first_element(attached_reference_ele, env, attached_reference_node, &rstr->requested_attached_ref);
	}
    axutil_qname_free(attached_reference_qname, env);

    /*Unattached reference*/
	unattached_reference_qname = axutil_qname_create(env, TRUST_REQUESTED_UNATTACHED_REFERENCE, rstr->wst_ns_uri, TRUST_WST);
	if(!unattached_reference_qname)
	{
		AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RequestedUnattachedReference Qname creation failed.");
		return AXIS2_FAILURE;
	}
	unattached_reference_ele = axiom_element_get_first_child_with_qname(rstr_ele, env, unattached_reference_qname, rstr_node, &unattached_reference_node);
	if(unattached_reference_ele)
	{
		axiom_element_get_first_element(unattached_reference_ele, env, unattached_reference_node, &rstr->requested_unattached_ref);
	}
	axutil_qname_free(unattached_reference_qname, env);

    return AXIS2_SUCCESS;
    
}


/*Build RSTR */
AXIS2_EXTERN axiom_node_t * AXIS2_CALL
trust_rstr_build_rstr(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *parent)
{
    axiom_node_t *rstr_node = NULL;
    axis2_char_t *key_size = NULL;
    
    rstr_node = (axiom_node_t*)trust_util_create_rstr_element(env, rstr->wst_ns_uri, rstr->attr_context);

    if(rstr_node)
    {
        if(rstr->token_type)
        {
            if(NULL == (axiom_node_t*)trust_util_create_token_type_element(env, rstr->wst_ns_uri, rstr_node, rstr->token_type))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR TokenType element creation failed.");
                return NULL;
            }
        }
        
        if(rstr->requested_sec_token)
        {
            if(NULL == (axiom_node_t*)trust_util_create_requested_security_token_element(env, rstr->wst_ns_uri, rstr_node, rstr->requested_sec_token))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR ReqSecToken element creation failed.");
                return NULL;
            }
            
        }

		if(rstr->requested_proof_token)
		{
			/*Appending generic proof token node to RSTR - Here proof token can be just a session key, entropy node with binary secret
			 * Creating the proof token is completely up to the user. Eventhough, there are some default util methods provided by trust_util to create 
			 * proof tokens. 
			*/
			axiom_node_add_child(rstr_node, env, rstr->requested_proof_token);
		}

        if(rstr->applies_to)
        {
            if(NULL == (axiom_node_t*)trust_util_create_applies_to_element(env, rstr_node, rstr->applies_to, TRUST_WSA_XMLNS))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR AppliesTo element creation failed.");
                return NULL;
            }
        }
        if(rstr->requested_attached_ref)
        {
            axiom_node_t* attached_ref = NULL;
            attached_ref = trust_util_create_req_attached_reference_element(env, rstr->wst_ns_uri, rstr_node);
            if(NULL == attached_ref)
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR AttachedReference element creation failed.");
                return NULL;   
            }
            axiom_node_add_child(attached_ref, env, rstr->requested_attached_ref);
            
        }
        if(rstr->requested_unattached_ref)
        {
            axiom_node_t* unattached_ref = NULL;
            unattached_ref = trust_util_create_req_unattached_reference_element(env, rstr->wst_ns_uri, rstr_node);
            if(NULL == unattached_ref)
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR UnattachedReference element creation failed.");
                return NULL;   
            }
            axiom_node_add_child(unattached_ref, env, rstr->requested_unattached_ref);
        }
        
        if(rstr->entropy)
        {
            if(NULL == trust_entropy_serialize(rstr->entropy, env, rstr_node))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR Entropy element creation failed.");
                return NULL;
            }
        }
        
        if(rstr->life_time)
        {
            if(NULL == trust_life_time_serialize(rstr->life_time, env, rstr_node))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] RSTR LifeTime element creation failed.");
                return NULL;
            }
        }
        
        if(rstr->key_size > 0)
        {
            /*INFO -keysize Malloc Size = 128 */
            key_size = AXIS2_MALLOC( env->allocator, sizeof(char)*128);
            sprintf(key_size, "%d", rstr->key_size);
            if(NULL == (axiom_node_t*)trust_util_create_key_size_element(env, rstr->wst_ns_uri, rstr_node, key_size))
            {
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[trust] KeySize element creation failed.");
                return NULL; 
            }
        }
        return rstr_node;
    }
	return NULL;
}

AXIS2_EXTERN axis2_char_t * AXIS2_CALL
trust_rstr_get_token_type(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->token_type;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_token_type(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axis2_char_t *token_type)
{
    if(token_type)
    {
        rstr->token_type = token_type;
        
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN axis2_char_t * AXIS2_CALL
trust_rstr_get_request_type(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->request_type;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_request_type(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axis2_char_t *request_type)
{
    if(request_type)
    {
        rstr->request_type = request_type;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN axiom_node_t * AXIS2_CALL
trust_rstr_get_requested_security_token(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->requested_sec_token;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_requested_security_token(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *security_token)
{
    if (security_token) 
    {
        rstr->requested_sec_token = security_token;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;

}

AXIS2_EXTERN axis2_char_t * AXIS2_CALL
trust_rstr_get_applies_to(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->applies_to;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_applies_to(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axis2_char_t *applies_to)
{
    if (applies_to) 
    {
        rstr->applies_to = applies_to;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN axiom_node_t * AXIS2_CALL
trust_rstr_get_requested_attached_reference(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->requested_attached_ref;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_requested_attached_reference(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *ref_node)
{
    if (ref_node) 
    {
        rstr->requested_attached_ref = ref_node;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN axiom_node_t * AXIS2_CALL
trust_rstr_get_requested_unattached_reference(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->requested_unattached_ref;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_requested_unattached_reference(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *ref_node)
{
    if (ref_node) 
    {
        rstr->requested_unattached_ref = ref_node;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN  axiom_node_t * AXIS2_CALL
trust_rstr_get_requested_proof_token(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->requested_proof_token;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_requested_proof_token(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axiom_node_t *proof_token)
{
    if (proof_token) 
    {
        rstr->requested_proof_token = proof_token;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN trust_entropy_t * AXIS2_CALL
trust_rstr_get_entropy(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->entropy;
}

AXIS2_EXTERN  axis2_status_t AXIS2_CALL
trust_rstr_set_entropy(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        trust_entropy_t *entropy)
{
    if (entropy) 
    {
        rstr->entropy = entropy;
        return AXIS2_SUCCESS;
    }

    return AXIS2_FAILURE;
}

AXIS2_EXTERN trust_life_time_t* AXIS2_CALL
trust_rstr_get_life_time(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->life_time;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_life_time(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        trust_life_time_t *life_time)
{
    if (life_time) 
    {
        rstr->life_time = life_time;
        return AXIS2_SUCCESS;
    }
    
    return AXIS2_FAILURE;
}

AXIS2_EXTERN axis2_bool_t AXIS2_CALL
trust_rstr_get_in_header(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->in_header;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_in_header(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        axis2_bool_t in_header)
{
    rstr->in_header = in_header;
    
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_char_t * AXIS2_CALL
trust_rstr_get_wst_ns_uri(
	trust_rstr_t *rstr,
	const axutil_env_t *env)
{
		return rstr->wst_ns_uri;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
trust_rstr_set_wst_ns_uri(
	trust_rstr_t *rstr,
	const axutil_env_t *env,
	axis2_char_t *wst_ns_uri)
{
		if(wst_ns_uri)
		{
			rstr->wst_ns_uri = wst_ns_uri;
			return AXIS2_SUCCESS;
		}

		return AXIS2_FAILURE;
}

AXIS2_EXTERN int AXIS2_CALL
trust_rstr_get_key_size(
        trust_rstr_t *rstr,
        const axutil_env_t *env)
{
    return rstr->key_size;
}

AXIS2_EXTERN  axis2_status_t AXIS2_CALL
trust_rstr_set_key_size(
        trust_rstr_t *rstr,
        const axutil_env_t *env,
        int key_size)
{
    rstr->key_size = key_size;
    return AXIS2_SUCCESS;
}