<?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
 *
 *     https://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.
 */

namespace Apache\Avro;

/**
 * Avro library code debugging functions
 * @package Avro
 */
class AvroDebug
{
    /**
     * @var int high debug level
     */
    public const DEBUG5 = 5;
    /**
     * @var int low debug level
     */
    public const DEBUG1 = 1;
    /**
     * @var int current debug level
     */
    public const DEBUG_LEVEL = self::DEBUG1;

    /**
     * @param string $format format string for the given arguments. Passed as is
     *                     to <code>vprintf</code>.
     * @param array $args array of arguments to pass to vsprinf.
     * @param int $debug_level debug level at which to print this statement
     * @returns boolean true
     */
    public static function debug($format, $args, $debug_level = self::DEBUG1)
    {
        if (self::isDebug($debug_level)) {
            vprintf($format . "\n", $args);
        }
        return true;
    }

    /**
     * @var int $debug_level
     * @returns boolean true if the given $debug_level is equivalent
     *                  or more verbose than than the current debug level
     *                  and false otherwise.
     */
    public static function isDebug($debug_level = self::DEBUG1)
    {
        return (self::DEBUG_LEVEL >= $debug_level);
    }

    /**
     * @param string $str
     * @param string $joiner string used to join
     * @returns string hex-represented bytes of each byte of $str
     * joined by $joiner
     */
    public static function hexString($str, $joiner = ' ')
    {
        return implode($joiner, self::hexArray($str));
    }

    /**
     * @param string $str
     * @returns string[] array of hex representation of each byte of $str
     */
    public static function hexArray($str)
    {
        return self::bytesArray($str);
    }

    /**
     * @param string $str
     * @param string $format format to represent bytes
     * @returns string[] array of each byte of $str formatted using $format
     */
    public static function bytesArray($str, $format = 'x%02x')
    {
        $x = array();
        foreach (str_split($str) as $b) {
            $x[] = sprintf($format, ord($b));
        }
        return $x;
    }

    /**
     * @param string $str
     * @param string $joiner string to join bytes of $str
     * @returns string of bytes of $str represented in decimal format
     * @uses decArray()
     */
    public static function decString($str, $joiner = ' ')
    {
        return implode($joiner, self::decArray($str));
    }

    /**
     * @param string $str
     * @returns string[] array of bytes of $str represented in decimal format ('%3d')
     */
    public static function decArray($str)
    {
        return self::bytesArray($str, '%3d');
    }

    /**
     * @param string $str
     * @param string $format one of 'ctrl', 'hex', or 'dec'.
     *                       See {@link self::asciiArray()} for more description
     * @param string $joiner
     * @returns string of bytes joined by $joiner
     * @uses asciiArray()
     */
    public static function asciiString($str, $format = 'ctrl', $joiner = ' ')
    {
        return implode($joiner, self::asciiArray($str, $format));
    }

    /**
     * @param string $str
     * @param string $format one of 'ctrl', 'hex', or 'dec' for control,
     * hexadecimal, or decimal format for bytes.
     * - ctrl: ASCII control characters represented as text.
     * For example, the null byte is represented as 'NUL'.
     * Visible ASCII characters represent themselves, and
     * others are represented as a decimal ('%03d')
     * - hex: bytes represented in hexadecimal ('%02X')
     * - dec: bytes represented in decimal ('%03d')
     * @returns string[] array of bytes represented in the given format.
     * @throws AvroException
     */
    public static function asciiArray($str, $format = 'ctrl')
    {
        if (!in_array($format, ['ctrl', 'hex', 'dec'])) {
            throw new AvroException('Unrecognized format specifier');
        }

        $ctrl_chars = array(
            'NUL',
            'SOH',
            'STX',
            'ETX',
            'EOT',
            'ENQ',
            'ACK',
            'BEL',
            'BS',
            'HT',
            'LF',
            'VT',
            'FF',
            'CR',
            'SO',
            'SI',
            'DLE',
            'DC1',
            'DC2',
            'DC3',
            'DC4',
            'NAK',
            'SYN',
            'ETB',
            'CAN',
            'EM',
            'SUB',
            'ESC',
            'FS',
            'GS',
            'RS',
            'US'
        );
        $x = array();
        foreach (str_split($str) as $b) {
            $db = ord($b);
            if ($db < 32) {
                switch ($format) {
                    case 'ctrl':
                        $x[] = str_pad($ctrl_chars[$db], 3, ' ', STR_PAD_LEFT);
                        break;
                    case 'hex':
                        $x[] = sprintf("x%02X", $db);
                        break;
                    case 'dec':
                        $x[] = str_pad($db, 3, '0', STR_PAD_LEFT);
                        break;
                }
            } else {
                if ($db < 127) {
                    $x[] = "  $b";
                } else {
                    if ($db == 127) {
                        switch ($format) {
                            case 'ctrl':
                                $x[] = 'DEL';
                                break;
                            case 'hex':
                                $x[] = sprintf("x%02X", $db);
                                break;
                            case 'dec':
                                $x[] = str_pad($db, 3, '0', STR_PAD_LEFT);
                                break;
                        }
                    } else {
                        if ('hex' === $format) {
                            $x[] = sprintf("x%02X", $db);
                        } else {
                            $x[] = str_pad($db, 3, '0', STR_PAD_LEFT);
                        }
                    }
                }
            }
        }
        return $x;
    }
}