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

namespace Apache\Ignite;

use Apache\Ignite\Exception\ClientException;
use Apache\Ignite\Internal\Utils\ArgumentChecker;

/**
 * Class representing Ignite client configuration.
 *
 * The configuration includes:
 *   - (mandatory) Ignite node endpoint(s)
 *   - (optional) user credentials for authentication
 *   - (optional) TLS options for secure connection
 *   - (optional) connection options
 */
class ClientConfiguration
{
    private $endpoints;
    private $userName;
    private $password;
    private $tlsOptions;
    private $timeout;
    private $sendChunkSize;
    private $receiveChunkSize;
    private $tcpNoDelay;

    const ENDPOINT_PORT_DEFAULT = 10800;

    /**
     * Creates an instance of Ignite client configuration
     * with the provided mandatory settings and default optional settings.
     *
     * By default, the client does not use authentication and secure connection.
     *
     * @param string ...$endpoints Ignite node endpoint(s). The client randomly connects/reconnects
     * to one of the specified node.
     *
     * @throws ClientException if error.
     */
    public function __construct(string ...$endpoints)
    {
        ArgumentChecker::notEmpty($endpoints, 'endpoints');
        $this->endpoints = array_map(array($this, 'parseEndpoint'), $endpoints);
        $this->userName = null;
        $this->password = null;
        $this->tlsOptions = null;
        $this->timeout = 0;
        $this->sendChunkSize = 0;
        $this->receiveChunkSize = 0;
        $this->tcpNoDelay = true;
    }
    
    /**
     * Returns Ignite node endpoints specified in the constructor.
     * 
     * @return string[] endpoints
     */
    public function getEndpoints(): array
    {
        return $this->endpoints;
    }

    /**
     * Sets username which will be used for authentication during the client's connection.
     *
     * If username is not set, the client does not use authentication during connection.
     * 
     * @param string|null $userName username. If null, authentication is disabled.
     * 
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setUserName(?string $userName): ClientConfiguration
    {
        $this->userName = $userName;
        return $this;
    }
    
    /**
     * Returns the current username.
     * 
     * @return string|null username or null (if authentication is disabled).
     */
    public function getUserName(): ?string
    {
        return $this->userName;
    }
    
    /**
     * Sets password which will be used for authentication during the client's connection.
     *
     * Password is ignored, if username is not set.
     * If password is not set, it is considered empty.
     * 
     * @param string|null $password password. If null, password is empty.
     * 
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setPassword(?string $password): ClientConfiguration
    {
        $this->password = $password;
        return $this;
    }
    
    /**
     * Returns the current password.
     * 
     * @return string|null password or null (if password is empty).
     */
    public function getPassword(): ?string
    {
        return $this->password;
    }
    
    /**
     * Enables and setup TLS connection.
     *
     * If not enabled (by default), the client does not use secure connection.
     *
     * @param array|null $tlsOptions TLS connection options in the format defined here: http://php.net/manual/en/context.ssl.php
     * If null, secure connection is not used.
     *
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setTLSOptions(?array $tlsOptions): ClientConfiguration
    {
        $this->tlsOptions = $tlsOptions;
        return $this;
    }
    
    /**
     * Returns the current TLS connection options.
     * 
     * @return array|null TLS connection options or null (if secure connection is not used).
     */
    public function getTLSOptions(): ?array
    {
        return $this->tlsOptions;
    }

    /**
     * Sets send/receive timeout.
     *
     * Default value is defined by the PHP settings.
     *
     * @param int $timeout send/receive timeout (in milliseconds).
     *
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setTimeout(int $timeout): ClientConfiguration
    {
        $this->timeout = $timeout;
        return $this;
    }

    /**
     * Returns the current send/receive timeout.
     *
     * @return int send/receive timeout (in milliseconds).
     */
    public function getTimeout(): int
    {
        return $this->timeout;
    }

    /**
     * Sets the size of the send chunk.
     *
     * 8192 bytes by default.
     *
     * @param int $size size of the send chunk (in bytes).
     *
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setSendChunkSize(int $size): ClientConfiguration
    {
        $this->sendChunkSize = $size;
        return $this;
    }

    /**
     * Returns the current size of the send chunk.
     *
     * @return int size of the send chunk (in bytes).
     */
    public function getSendChunkSize(): int
    {
        return $this->sendChunkSize;
    }

    /**
     * Sets the size of the receive chunk.
     *
     * 8192 bytes by default.
     *
     * @param int $size size of the receive chunk (in bytes).
     *
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setReceiveChunkSize(int $size): ClientConfiguration
    {
        $this->receiveChunkSize = $size;
        return $this;
    }

    /**
     * Returns the current size of the receive chunk.
     *
     * @return int size of the receive chunk (in bytes).
     */
    public function getReceiveChunkSize(): int
    {
        return $this->receiveChunkSize;
    }

    /**
     * Disables/enables the TCP Nagle algorithm.
     *
     * Enabled by default.
     *
     * @param bool $tcpNoDelay true to enable, false to disable.
     *
     * @return ClientConfiguration the same instance of the ClientConfiguration.
     */
    public function setTcpNoDelay(bool $tcpNoDelay): ClientConfiguration
    {
        $this->tcpNoDelay = $tcpNoDelay;
        return $this;
    }

    /**
     * Returns the current status of the TCP Nagle algorithm.
     *
     * @return bool true if enabled, false if disabled.
     */
    public function getTcpNoDelay(): bool
    {
        return $this->tcpNoDelay;
    }

    private function parseEndpoint(string $endpoint): string
    {
        $endpoint = trim($endpoint);
        $host = $endpoint;
        $port = null;
        $parsed = explode(':', $endpoint);
        if (count($parsed) > 2) {
            // IPv6 address
            $index = strrpos($endpoint, ']:');
            if ($index !== false) {
                $host = substr($endpoint, 0, $index + 1);
                $port = substr($endpoint, $index + 2);
            }
            $first = $host[0];
            $last = $host[strlen($host) - 1];
            if ($first === '[' || $last === ']') {
                if (!($first === '[' && $last === ']')) {
                    ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
                }
            } else {
                $host = sprintf('[%s]', $host);
            }
        }
        else {
            // IPv4 address
            $host = $parsed[0];
            if (count($parsed) === 2) {
                $port = $parsed[1];
            }
        }
        if ($port === null) {
            $port = self::ENDPOINT_PORT_DEFAULT;
        } elseif (!ctype_digit($port)) {
            ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
        }
        return sprintf('%s:%s', $host, $port);
    }
}