<?

class array2xml
{
    private $_data = array();

    private static $_defTagArray = array('#name' => '', '#value' => '', '#attrs' => array(), '#type' => '');

    public function assign($name, $value)
    {
        if (self::_isValidTagname($name))
        {
            $this->_data = self::_convertArray(array($name =>$value));
        }
    }

    /**
     * Конвертирует входящий массив исходя из его типа
     * в массив вида @link self::$_defTagArray
     * @param array $array входящий массив
     * @param int $arrayNumInSet[OPTIONAL] порядковый номер массива
     *      (если передаётся несколько массивов тегов на одном уровне)
     * @return array массив, содержащий в качестве значения массив вида @link self::$_defTagArray
     *      (array($arrayNumInSet => self::$_defTagArray))
     */
    private static function _convertArray($array, $arrayNumInSet = 0)
    {
        //если просто значение - возвращаем его
        if (!is_array($array))
            return $array;
        //заполняем массив значениями по умолчанию
        $tagArray = self::$_defTagArray;
        $arrayType = self::_getArrayType($array);
        switch ($arrayType)
        {
            case 'simple':
                $tagArray['#name'] = self::_getSimpleTagName($array);
                $tagArray['#value'] = self::_getSimpleTagValue($array);
                break;
            case 'complex':
                $tagArray['#name'] = self::_getComplexTagName($array);
                $tagArray['#type'] = self::_getComplexTagType($array);
                $tagArray['#attrs'] = self::_getComplexTagAttrs($array);
                $tagArray['#value'] = self::_getComplexTagValue($array);
                break;
        }
        return array($arrayNumInSet => $tagArray);
    }

    /**
     * Возвращает тип переданного массива (тега).
     * Мы можем задать массив одного из трёх типов: простой тег, сложный тег, массив тегов
     * @param array $array тег
     * return string|bool ('numeric', 'simple', 'complex')|false если не массив
     */
    private static function _getArrayType($array)
    {
        if (!is_array($array))
            return false;
        $firstKey = array_keys($array);
        $firstKey = $firstKey[0];
        if (is_int($firstKey))
            return 'numeric';
        if (array_key_exists($firstKey, self::$_defTagArray))
            return 'complex';
        return 'simple';
    }

    /**
     * Возвращает значение тега (в виде массива) для простого тега
     *  @uses self::_convertArray() для формирования значения
     *  @uses self::_processNumericArray() если передан массив тегов
     * @param array $array тег
     * @return array
     */
    private static function _getSimpleTagValue($array)
    {
        $value = array_values($array);
        $value = $value[0];
        if (self::_getArrayType($value) == 'numeric')
            return self::_processNumericArray($value);
        return self::_convertArray($value);
    }

    /**
     * Возвращает имя тега для простого тега
     * @param array $array тег
     * @return string
     */
    private static function _getSimpleTagName($array)
    {
        $keys = array_keys($array);
        $key = $keys[0];
        if (self::_isValidTagname($key))
            return $key;
        return '';
    }

    /**
     * Возвращает имя сложного тега
     * @param array $array тег
     * @return string
     */
    private static function _getComplexTagName($array)
    {
        return (isset ($array['#name'])) ? $array['#name'] : '';
    }

    /**
     * Возвращает тип сложного тега (подразумевается либо пустой, либо 'raw')
     * @param array $array тег
     * @return string
     */
    private static function _getComplexTagType($array)
    {
        return (isset ($array['#type'])) ? $array['#type'] : '';
    }

    /**
     * Возвращает атрибуты сложного тега
     * @param array $array тег
     * @return array
     */
    private static function _getComplexTagAttrs($array)
    {
        return (isset ($array['#attrs'])) ? $array['#attrs'] : array();
    }

    /**
     * Возвращает значение сложного тега (в виде массива)
     *  @uses self::_convertArray() для формирования значения
     *  @uses self::_processNumericArray() если передан массив тегов
     * @param array $array тег
     * @return array
     */
    private static function _getComplexTagValue($array)
    {
        if (!isset ($array['#value']))
            return '';
        $value = $array['#value'];
        if (self::_getArrayType($value) == 'numeric')
            return self::_processNumericArray($value);
        return self::_convertArray($value);
    }

    /**
     * Обрабатывает массив массивов тегов
     * @param array $arrays
     * @return array обработанный массив массивов тегов
     */
    private static function _processNumericArray($arrays)
    {
        $keys = array_keys($arrays);
        $numKeys = array_filter($keys, 'is_int');
        $convertedArrays = array();
        foreach ($numKeys as $numKey)
        {
            $convertedArrays = array_merge_recursive($convertedArrays, self::_convertArray($arrays[$numKey], $numKey));
        }
        return $convertedArrays;
    }

    /**
     * Проверяет, может ли быть переданное значение быть именем тега
     * @param string $tagName
     * @return bool
     */
    private static function _isValidTagname($tagName)
    {
        if (!empty ($tagName) && !is_int($tagName))
            return true;
        return false;
    }

    public function getData()
    {
        return $this->_data;
    }
}