/*
 * 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.felix.scr.impl;

import java.util.*;

/**
 * A property descriptor that contains the information for properties
 * defined in the descriptor
 *
 */
public class PropertyMetadata {

	// Name of the property (required)
	private String m_name;

	// Type of the property (optional)
	private String m_type = "String";

	// Value of the type (optional)
	private Object m_value;

	// Flag that indicates if this PropertyMetadata has been validated and thus has become immutable
	private boolean m_validated = false;

	/**
	 * Set the name
	 *
	 * @param name
	 */
	public void setName(String name) {
		if (m_validated == true) {
			return;
		}

		m_name = name;
	}


	/**
	 * Set the type
	 *
	 * @param type
	 */
	public void setType(String type) {
		if (m_validated == true) {
			return;
		}
		m_type = type;
	}

	/**
	 * Set the value
	 *
	 * @param value
	 */
	public void setValue(String value) {
		if (m_validated == true) {
			return;
		}

        m_value = toType( value );
	}

    /**
     * Set multiple values as an array, where the values are contained in
     * the string as one value per line.
     *
     * @param values
     */
    public void setValues(String values) {
        // splite the values and convert to boxed objects
        List valueList = new ArrayList();
        StringTokenizer tokener = new StringTokenizer(values, "\r\n");
        while (tokener.hasMoreTokens()) {
            String value = tokener.nextToken().trim();
            if (value.length() > 0) {
                valueList.add(toType( value ));
            }
        }

        // 112.4.5 Except for String objects, the result will be translated to an array of primitive types.
        if(m_type.equals("String")) {
            m_value = valueList.toArray( new String[valueList.size()] );
        }
        else if(m_type.equals("Long")) {
            long[] array = new long[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Long) valueList.get(i)).longValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Double")) {
            double[] array = new double[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Double) valueList.get(i)).doubleValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Float")) {
            float[] array = new float[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Float) valueList.get(i)).floatValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Integer")) {
            int[] array = new int[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Integer) valueList.get(i)).intValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Byte")) {
            byte[] array = new byte[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Byte) valueList.get(i)).byteValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Char")) {
            //TODO: verify if this is adequate for Characters
            char[] array = new char[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Character) valueList.get(i)).charValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Boolean")) {
            boolean[] array = new boolean[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Boolean) valueList.get(i)).booleanValue();
            }
            m_value = array;
        }
        else if(m_type.equals("Short")) {
            short[] array = new short[valueList.size()];
            for (int i=0; i < array.length; i++) {
                array[i] = ((Short) valueList.get(i)).shortValue();
            }
            m_value = array;
        }
        else {
            throw new IllegalArgumentException("Undefined property type '"+m_type+"'");
        }
    }

    /**
     * Get the name of the property
     *
     * @return the name of the property
     */
    public String getName() {
        return m_name;
    }

    /**
     * Get the type of the property
     *
     * @return the type of the property
     */
    public String getType() {
        return m_type;
    }

    /**
     * Get the value of the property
     *
     * @return the value of the property as an Object
     */
    public Object getValue() {
        return m_value;
    }

    /**
     * Method used to verify if the semantics of this metadata are correct
     */
    public void validate( ComponentMetadata componentMetadata )
    {
        if ( m_name == null )
        {
            throw componentMetadata.validationFailure( "Property name attribute is mandatory" );
        }
    }

    private Object toType(String value) {
        // 112.4.5 Parsing of the value is done by the valueOf(String) method (P. 291)
        // Should the type accept lowercase too?
        if(m_type.equals("String")) {
            return String.valueOf(value);
        }
        else if(m_type.equals("Long")) {
            return Long.valueOf(value);
        }
        else if(m_type.equals("Double")) {
            return Double.valueOf(value);
        }
        else if(m_type.equals("Float")) {
            return Float.valueOf(value);
        }
        else if(m_type.equals("Integer")) {
            return Integer.valueOf(value);
        }
        else if(m_type.equals("Byte")) {
            return Byte.valueOf(value);
        }
        else if(m_type.equals("Char")) {
            char c = ( value.length() > 0 ) ? value.charAt( 0 ) : 0;
            return new Character( c );
        }
        else if(m_type.equals("Boolean")) {
            return Boolean.valueOf(value);
        }
        else if(m_type.equals("Short")) {
            return Short.valueOf(value);
        }
        else {
            throw new IllegalArgumentException("Undefined property type '"+m_type+"'");
        }
    }
}