<?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\Schema;

/**
 * @package Avro
 */
class AvroName
{
    /**
     * @var string character used to separate names comprising the fullname
     */
    public const NAME_SEPARATOR = '.';

    /**
     * @var string regular expression to validate name values
     */
    public const NAME_REGEXP = '/^[A-Za-z_][A-Za-z0-9_]*$/';
    /**
     * @var string valid names are matched by self::NAME_REGEXP
     */
    private $name;
    /**
     * @var string
     */
    private $namespace;
    /**
     * @var string
     */
    private $fullname;
    /**
     * @var string Name qualified as necessary given its default namespace.
     */
    private $qualified_name;

    /**
     * @param string $name
     * @param string $namespace
     * @param string $default_namespace
     */
    public function __construct($name, $namespace, $default_namespace)
    {
        if (!is_string($name) || empty($name)) {
            throw new AvroSchemaParseException('Name must be a non-empty string.');
        }

        if (strpos($name, self::NAME_SEPARATOR) && self::checkNamespaceNames($name)) {
            $this->fullname = $name;
        } elseif (0 === preg_match(self::NAME_REGEXP, $name)) {
            throw new AvroSchemaParseException(sprintf('Invalid name "%s"', $name));
        } elseif (!is_null($namespace)) {
            $this->fullname = self::parseFullname($name, $namespace);
        } elseif (!is_null($default_namespace)) {
            $this->fullname = self::parseFullname($name, $default_namespace);
        } else {
            $this->fullname = $name;
        }

        [$this->name, $this->namespace] = self::extractNamespace($this->fullname);
        $this->qualified_name = (is_null($this->namespace) || $this->namespace === $default_namespace)
            ? $this->name
            : $this->fullname;
    }

    /**
     * @param string $namespace
     * @returns boolean true if namespace is composed of valid names
     * @throws AvroSchemaParseException if any of the namespace components
     *                                  are invalid.
     */
    private static function checkNamespaceNames($namespace)
    {
        foreach (explode(self::NAME_SEPARATOR, $namespace) as $n) {
            if (empty($n) || (0 === preg_match(self::NAME_REGEXP, $n))) {
                throw new AvroSchemaParseException(sprintf('Invalid name "%s"', $n));
            }
        }
        return true;
    }

    /**
     * @param string $name
     * @param string $namespace
     * @returns string
     * @throws AvroSchemaParseException if any of the names are not valid.
     */
    private static function parseFullname($name, $namespace)
    {
        if (!is_string($namespace) || empty($namespace)) {
            throw new AvroSchemaParseException('Namespace must be a non-empty string.');
        }
        self::checkNamespaceNames($namespace);
        return $namespace . '.' . $name;
    }

    /**
     * @returns string[] array($name, $namespace)
     */
    public static function extractNamespace($name, $namespace = null)
    {
        $parts = explode(self::NAME_SEPARATOR, $name);
        if (count($parts) > 1) {
            $name = array_pop($parts);
            $namespace = implode(self::NAME_SEPARATOR, $parts);
        }
        return [$name, $namespace];
    }

    /**
     * @returns boolean true if the given name is well-formed
     *          (is a non-null, non-empty string) and false otherwise
     */
    public static function isWellFormedName($name)
    {
        return (is_string($name) && !empty($name) && preg_match(self::NAME_REGEXP, $name));
    }

    /**
     * @returns array array($name, $namespace)
     */
    public function nameAndNamespace()
    {
        return [$this->name, $this->namespace];
    }

    /**
     * @returns string fullname
     * @uses $this->fullname()
     */
    public function __toString()
    {
        return $this->fullname();
    }

    /**
     * @returns string
     */
    public function fullname()
    {
        return $this->fullname;
    }

    /**
     * @returns string name qualified for its context
     */
    public function qualifiedName()
    {
        return $this->qualified_name;
    }
}