<?php

/**

 * 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 log4php

 */

/**

 * Most of the work of the {@link LoggerPatternLayout} class

 * is delegated to the {@link LoggerPatternParser} class.

 *

 * <p>It is this class that parses conversion patterns and creates

 * a chained list of {@link LoggerPatternConverter} converters.</p>

 *

 * @version $Revision: 1395467 $

 * @package log4php

 * @subpackage helpers

 *

 * @since 0.3

 */

class LoggerPatternParser {

    /** Escape character for conversion words in the conversion pattern. */

    const ESCAPE_CHAR = '%';

    /** Maps conversion words to relevant converters. */

    private $converterMap;

    /** Conversion pattern used in layout. */

    private $pattern;

    /** Regex pattern used for parsing the conversion pattern. */

    private $regex;

    /**

     * First converter in the chain.

     * @var LoggerPatternConverter

     */

    private $head;

    /** Last converter in the chain. */

    private $tail;

    public function __construct($pattern, $converterMap) {

        $this->pattern = $pattern;

        $this->converterMap = $converterMap;

        // Construct the regex pattern

        $this->regex =

            '/' .                       // Starting regex pattern delimiter

            self::ESCAPE_CHAR .         // Character which marks the start of the conversion pattern

            '(?P<modifiers>[0-9.-]*)' . // Format modifiers (optional)

            '(?P<word>[a-zA-Z]+)' .     // The conversion word

            '(?P<option>{[^}]*})?' .    // Conversion option in braces (optional)

            '/';                        // Ending regex pattern delimiter

    }

    /**

     * Parses the conversion pattern string, converts it to a chain of pattern

     * converters and returns the first converter in the chain.

     *

     * @return LoggerPatternConverter

     */

    public function parse() {

        // Skip parsing if the pattern is empty

        if (empty($this->pattern)) {

            $this->addLiteral('');

            return $this->head;

        }

        // Find all conversion words in the conversion pattern

        $count = preg_match_all($this->regex, $this->pattern, $matches, PREG_OFFSET_CAPTURE);

        if ($count === false) {

            $error = error_get_last();

            throw new LoggerException("Failed parsing layotut pattern: {$error['message']}");

        }

        $prevEnd = 0;

        foreach ($matches[0] as $key => $item) {

            // Locate where the conversion command starts and ends

            $length = strlen($item[0]);

            $start = $item[1];

            $end = $item[1] + $length;

            // Find any literal expressions between matched commands

            if ($start > $prevEnd) {

                $literal = substr($this->pattern, $prevEnd, $start - $prevEnd);

                $this->addLiteral($literal);

            }

            // Extract the data from the matched command

            $word = !empty($matches['word'][$key]) ? $matches['word'][$key][0] : null;

            $modifiers = !empty($matches['modifiers'][$key]) ? $matches['modifiers'][$key][0] : null;

            $option = !empty($matches['option'][$key]) ? $matches['option'][$key][0] : null;

            // Create a converter and add it to the chain

            $this->addConverter($word, $modifiers, $option);

            $prevEnd = $end;

        }

        // Add any trailing literals

        if ($end < strlen($this->pattern)) {

            $literal = substr($this->pattern, $end);

            $this->addLiteral($literal);

        }

        return $this->head;

    }

    /**

     * Adds a literal converter to the converter chain.

     * @param string $string The string for the literal converter.

     */

    private function addLiteral($string) {

        $converter = new LoggerPatternConverterLiteral($string);

        $this->addToChain($converter);

    }

    /**

     * Adds a non-literal converter to the converter chain.

     *

     * @param string $word The conversion word, used to determine which

     *  converter will be used.

     * @param string $modifiers Formatting modifiers.

     * @param string $option Option to pass to the converter.

     */

    private function addConverter($word, $modifiers, $option) {

        $formattingInfo = $this->parseModifiers($modifiers);

        $option = trim($option, "{} ");

        if (isset($this->converterMap[$word])) {

            $converter = $this->getConverter($word, $formattingInfo, $option);

            $this->addToChain($converter);

        } else {

            trigger_error("log4php: Invalid keyword '%$word' in converison pattern. Ignoring keyword.", E_USER_WARNING);

        }

    }

    /**

     * Determines which converter to use based on the conversion word. Creates

     * an instance of the converter using the provided formatting info and

     * option and returns it.

     *

     * @param string $word The conversion word.

     * @param LoggerFormattingInfo $info Formatting info.

     * @param string $option Converter option.

     *

     * @throws LoggerException

     *

     * @return LoggerPatternConverter

     */

    private function getConverter($word, $info, $option) {

        if (!isset($this->converterMap[$word])) {

            throw new LoggerException("Invalid keyword '%$word' in converison pattern. Ignoring keyword.");

        }

        $converterClass = $this->converterMap[$word];

        if (!class_exists($converterClass)) {

            throw new LoggerException("Class '$converterClass' does not exist.");

        }

        $converter = new $converterClass($info, $option);

        if (!($converter instanceof LoggerPatternConverter)) {

            throw new LoggerException("Class '$converterClass' is not an instance of LoggerPatternConverter.");

        }

        return $converter;

    }

    /** Adds a converter to the chain and updates $head and $tail pointers. */

    private function addToChain(LoggerPatternConverter $converter) {

        if (!isset($this->head)) {

            $this->head = $converter;

            $this->tail = $this->head;

        } else {

            $this->tail->next = $converter;

            $this->tail = $this->tail->next;

        }

    }

    /**

     * Parses the formatting modifiers and produces the corresponding

     * LoggerFormattingInfo object.

     *

     * @param string $modifier

     * @return LoggerFormattingInfo

     * @throws LoggerException

     */

    private function parseModifiers($modifiers) {

        $info = new LoggerFormattingInfo();

        // If no modifiers are given, return default values

        if (empty($modifiers)) {

            return $info;

        }

        // Validate

        $pattern = '/^(-?[0-9]+)?\.?-?[0-9]+$/';

        if (!preg_match($pattern, $modifiers)) {

            trigger_error("log4php: Invalid modifier in conversion pattern: [$modifiers]. Ignoring modifier.", E_USER_WARNING);

            return $info;

        }

        $parts = explode('.', $modifiers);

        if (!empty($parts[0])) {

            $minPart = (integer)$parts[0];

            $info->min = abs($minPart);

            $info->padLeft = ($minPart > 0);

        }

        if (!empty($parts[1])) {

            $maxPart = (integer)$parts[1];

            $info->max = abs($maxPart);

            $info->trimLeft = ($maxPart < 0);

        }

        return $info;

    }

}