<?php

namespace Application\Workers\Udp;

use Application\Logger\AppLogger;
use RuntimeException;

/**
 * Отправка данных через UDP.
 */
class UdpSender
{
    const SEND_BYTES_MAX = 1500;

    /** @var string */
    protected $host;

    /** @var integer */
    protected $port;

    /** @var AppLogger */
    protected $logger;

    /** @var integer|string */
    protected $code;

    /** @var string */
    protected $name;

    /** @var resource */
    protected $socket;

    /** @var array */
    protected $splits;

    /**
     * @param string $host
     * @param integer $port
     */
    public function __construct($host, $port)
    {
        $this->host = $host;
        $this->port = $port;
        $this->logger = new AppLogger('Request');
    }

    /**
     * Применить код отправляемого файла.
     *
     * @param integer|string $code
     * @return UdpSender
     */
    public function withCode($code)
    {
        $this->code = $code;
        return $this;
    }

    /**
     * Применить наименование отправляемого файла.
     *
     * @param string $name
     * @return UdpSender
     */
    public function withName($name)
    {
        $this->name = $name;
        return $this;
    }

    /**
     * Отправить данные.
     *
     * @param string $data
     * @return void
     */
    public function send($data)
    {
        $this->createSocket();
        $this->splitWithUnicode($data);
        $this->sendMetadata();
        $this->sendSplits();
        $this->sendEnding();
        $this->closeSocket();
    }

    /**
     * Создать сокет для передачи данных.
     *
     * @return void
     */
    protected function createSocket()
    {
        $this->socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
        if ($this->socket === false) {
            $errorCode = socket_last_error();
            $errorMessage = socket_strerror($errorCode);
            $this->logger->critical('Невозможно создать сокет для отправки данных.', ['errorCode' => $errorCode, 'errorMessage' => $errorMessage]);
            throw new RuntimeException('Невозможно создать сокет для отправки данных.');
        }
    }

    /**
     * Разбить строку на символы с учётом Unicode.
     *
     * @param string $data
     * @return void
     */
    protected function splitWithUnicode($data)
    {
        $this->splits = [];
        $maxLength = self::SEND_BYTES_MAX / 2;
        $dataLength = mb_strlen($data, "UTF-8");
        for ($i = 0; $i < $dataLength; $i += $maxLength) {
            $this->splits[] = mb_substr($data, $i, $maxLength, "UTF-8");
        }
    }

    /**
     * Отправить метаданные.
     *
     * @return void
     */
    protected function sendMetadata()
    {
        $metadata = [
            'countSplits' => count($this->splits),
        ];
        if ($this->code) {
            $metadata['code'] = $this->code;
        }
        if ($this->name) {
            $metadata['name'] = $this->name;
        }
        $this->logger->debug('Отправка метаданных.', ['metadata' => $metadata]);
        $this->sendDataWithHash(json_encode($metadata));
    }

    /**
     * Отправить данные с хэшем.
     *
     * @param string $data
     * @return void
     */
    protected function sendDataWithHash($data)
    {
        $hash = hash('crc32', $data);
        $hashAndData = $hash . $data;
        $this->sendData($hashAndData);
    }

    /**
     * Отправить данные.
     *
     * @param string $data
     * @return void
     */
    protected function sendData($data)
    {
        $sent = socket_sendto($this->socket, $data, strlen($data), 0, $this->host, $this->port);
        if ($sent === false) {
            $errorCode = socket_last_error();
            $errorMessage = socket_strerror($errorCode);
            $this->logger->warning('Данные через сокет не отправлены.', ['errorCode' => $errorCode, 'errorMessage' => $errorMessage]);
        }
        time_sleep_until(microtime(true) + .001);
    }

    /**
     * Отправить части данных.
     *
     * @return void
     */
    protected function sendSplits()
    {
        $this->logger->debug('Отправка данных через сокет.', ['countSplits' => count($this->splits)]);
        foreach ($this->splits as $split) {
            $this->sendDataWithHash($split);
        }
    }

    /**
     * Отправить строку окончания.
     *
     * @return void
     */
    protected function sendEnding()
    {
        $endingString = chr(0);
        $this->sendData($endingString);
    }

    /**
     * Закрыть сокет.
     *
     * @return void
     */
    protected function closeSocket()
    {
        socket_close($this->socket);
    }

}

<?php

namespace Application\Services\ReceiveFiles;

use Application\Logger\AppLogger;
use RuntimeException;

class ReceiveFiles
{

    const METADATA_KEYS_REQUIRED = ['name', 'code', 'countSplits'];

    /** @var AppLogger */
    protected $logger;

    /** @var array */
    protected $config;

    /** @var resource */
    protected $socket;

    /** @var string */
    protected $buffer;

    /** @var string */
    protected $address;

    /** @var array */
    protected $splits = [];

    /** @var array */
    protected $metadata = [];

    /** @var array */
    protected $hasErrors = [];

    public function initialize(array $config = [])
    {
        $this->logger = new AppLogger('Request');
    }

    public function initConfig(array $config)
    {
        $this->config = $config;
    }

    public function executeService()
    {
        $this->connectToSocket();
        while (true) {
            $this->receiveData();
            $this->defineData();
        }
    }

    protected function connectToSocket()
    {
        $host = $this->config['host'];
        $port = $this->config['port'];
        $this->logger->debug('Подключение к сокету.', ['host' => $host, 'port' => $port]);
        $this->socket = @socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
        if (@socket_bind($this->socket, $host, $port) === false) {
            $errorCode = socket_last_error();
            $errorMessage = socket_strerror($errorCode);
            $this->logger->critical('Невозможно подключиться к сокету.', ['host' => $host, 'port' => $port, 'code' => $errorCode, 'message' => $errorMessage]);
            exit("Failed to bind socket on $host:$port, $errorCode: $errorMessage" . PHP_EOL);
        }
        $this->logger->info('Подключено к сокету.', ['host' => $host, 'port' => $port]);
    }

    protected function receiveData()
    {
        @socket_recvfrom($this->socket, $this->buffer, 52428800, 0, $ip, $port);
        $this->address = "$ip:$port";
        $this->logger->debug('Приняты данные', ['address' => $this->address, 'length' => strlen($this->buffer)]);
    }

    protected function defineData()
    {
        if ($this->checkForFirstBlock()) {
            $this->initializeTransmitting();
        } elseif ($this->checkReceiveComplete()) {
            $this->completeReceive();
            $this->resetFile();
        } else {
            $this->addSection();
        }
    }

    protected function checkForFirstBlock()
    {
        $firstBlock = !isset($this->splits[$this->address]);
        if ($firstBlock) {
            $this->logger->debug('Получен первый блок данных.', ['address' => $this->address]);
        }
        return $firstBlock;
    }

    protected function initializeTransmitting()
    {
        $this->splits[$this->address] = [];
        $data = $this->fetchDataFromBufferWithHash();
        $metadata = json_decode($data, true);
        if (!isset($metadata)) {
            $this->logger->error('Не удалось извлечь метаданные из первого блока.', ['address' => $this->address]);
            return;
        }

        foreach (self::METADATA_KEYS_REQUIRED as $checkKey) {
            if (empty($metadata[$checkKey])) {
                $this->logger->error('Отсутствует необходимый ключ в метаданных.', ['keyAbsent' => $checkKey, 'metadata' => $metadata]);
            }
        }

        $this->logger->debug('Сохранены метаданные.', ['address' => $this->address, 'metadata' => $metadata]);
        $this->metadata[$this->address] = $metadata;
    }

    protected function fetchDataFromBufferWithHash()
    {
        $hash = substr($this->buffer, 0, 8);
        $data = substr($this->buffer, 8);
        if ($hash !== hash('crc32', $data)) {
            $this->logger->debug('Контрольная сумма блока не совпадает!', ['address' => $this->address]);
            $this->hasErrors[$this->address] = true;
            return false;
        }
        return $data;
    }

    protected function checkReceiveComplete()
    {
        if (!isset($this->metadata[$this->address])) {
            return false;
        }
        $complete = ord($this->buffer) === 0 && strlen($this->buffer) === 1;
        if ($complete) {
            $this->logger->debug('Получен код завершения передачи файла.', ['address' => $this->address]);
        }
        return $complete;
    }

    protected function completeReceive()
    {
        if ($this->hasErrors[$this->address]) {
            $this->logger->info('Отмена сохранения результата из-за ошибок.', ['address' => $this->address, 'metadata' => $this->metadata[$this->address]]);
            return;
        }

        if ($this->metadata[$this->address]['countSplits'] !== count($this->splits[$this->address])) {
            $this->logger->info('Количество принятых секций не совпадает.', ['address' => $this->address, 'countSplits' => count($this->splits[$this->address]), 'countExpected' => $this->metadata[$this->address]['countSplits']]);
            return;
        }

        $this->logger->info('Завершён приём файла.', ['address' => $this->address, 'metadata' => $this->metadata[$this->address]]);
        // ... здесь пропущены строки. Предполагается сохранение полученных данных: implode('', $this->splits[$this->address])
    }

    protected function resetFile()
    {
        unset($this->splits[$this->address]);
        unset($this->metadata[$this->address]);
        unset($this->hasErrors[$this->address]);
    }

    protected function addSection()
    {
        $data = $this->fetchDataFromBufferWithHash();
        if ($data) {
            $this->splits[$this->address][] = $data;
            $this->logger->debug('Добавлен блок данных.', ['address' => $this->address, 'iterator' => count($this->splits[$this->address])]);
        }
    }

}