<?php
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/

namespace Magento\Framework\Code;

use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\Exception\FileSystemException;
use Magento\Framework\Exception\RuntimeException;
use Magento\Framework\Filesystem\Directory\WriteFactory;
use Magento\Framework\Filesystem\Directory\WriteInterface;
use Magento\Framework\Lock\LockManagerInterface;

/**
* Clean generated code, DI configuration and cache folders
*/
class GeneratedFiles
{
/**
* Regenerate flag file name
*/
const REGENERATE_FLAG = '/var/.regenerate';

/**
* Regenerate lock file name
*/
const REGENERATE_LOCK = self::REGENERATE_FLAG . '.lock';

/**
* Acquire regenerate lock timeout
*/
const REGENERATE_LOCK_TIMEOUT = 5;

/**
* @var DirectoryList
*/
private $directoryList;

/**
* @var WriteInterface
*/
private $write;

/**
* @var LockManagerInterface
*/
private $lockManager;

/**
* GeneratedFiles constructor.
*
* @param DirectoryList $directoryList
* @param WriteFactory $writeFactory
* @param LockManagerInterface $lockManager
*/
public function __construct(
DirectoryList $directoryList,
WriteFactory $writeFactory,
LockManagerInterface $lockManager
) {
$this->directoryList = $directoryList;
$this->write = $writeFactory->create(BP);
$this->lockManager = $lockManager;
}

/**
* Create flag for cleaning up generated content
*
* @return void
*/
public function requestRegeneration()
{
$this->write->touch(self::REGENERATE_FLAG);
}

/**
* Clean generated code, generated metadata and cache directories
*
* @return void
*
* @deprecated 100.1.0
* @see \Magento\Framework\Code\GeneratedFiles::cleanGeneratedFiles
*/
public function regenerate()
{
$this->cleanGeneratedFiles();
}

/**
* Clean generated code, generated metadata and cache directories
*
* @return void
*/
public function cleanGeneratedFiles()
{
if ($this->isCleanGeneratedFilesAllowed() && $this->acquireLock()) {
try {
$this->write->delete(self::REGENERATE_FLAG);
$this->deleteFolder(DirectoryList::GENERATED_CODE);
$this->deleteFolder(DirectoryList::GENERATED_METADATA);
$this->deleteFolder(DirectoryList::CACHE);
} catch (FileSystemException $exception) {
// A filesystem error occurred, possible concurrency error while trying
// to delete a generated folder being used by another process.
// Request regeneration for the next and unlock
$this->requestRegeneration();
} finally {
$this->lockManager->unlock(self::REGENERATE_LOCK);
}
}
}

/**
* Clean generated files is allowed if requested and not locked
*
* @return bool
*/
private function isCleanGeneratedFilesAllowed(): bool
{
try {
$isAllowed = $this->write->isExist(self::REGENERATE_FLAG)
&& !$this->lockManager->isLocked(self::REGENERATE_LOCK);
} catch (FileSystemException | RuntimeException $e) {
// Possible filesystem problem
$isAllowed = false;
}

return $isAllowed;
}

/**
* Acquire lock for performing operations
*
* @return bool
*/
private function acquireLock(): bool
{
try {
$lockAcquired = $this->lockManager->lock(self::REGENERATE_LOCK, self::REGENERATE_LOCK_TIMEOUT);
} catch (RuntimeException $exception) {
// Lock not acquired due to possible filesystem problem
$lockAcquired = false;
}

return $lockAcquired;
}

/**
* Delete folder by path
*
* @param string $pathType
* @return void
*/
private function deleteFolder(string $pathType): void
{
$relativePath = $this->write->getRelativePath($this->directoryList->getPath($pathType));
if ($this->write->isDirectory($relativePath)) {
$this->write->delete($relativePath);
}
}
}