<?php

namespace App\Tests\Unit\Service\Cron\Job;

use App\Entity\Core\File;
use App\Repository\Core\FileRepository;
use App\Service\Cron\Job\CleanTempFiles;
use App\Service\Cron\UI\CronUIInterface;
use App\Service\File\Storage\LocalStorage;
use App\Service\Utils\DatesUtils;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\QueryBuilder;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;

class TestableCleanTempFile extends CleanTempFiles
{
    public function listFilesToDelete(\DateTime $maxDate): array
    {
        return parent::listFilesToDelete($maxDate);
    }

    public function deleteFiles(array $files): void
    {
        parent::deleteFiles($files);
    }

    public function getQueryConditions(QueryBuilder $queryBuilder, \DateTime $maxDate): void
    {
        parent::getQueryConditions($queryBuilder, $maxDate);
    }
}

class CleanTempFilesTest extends TestCase
{
    private CronUIInterface|MockObject $ui;
    private MockObject|LoggerInterface $logger;
    private FileRepository|MockObject $fileRepository;
    private Connection|MockObject $connection;
    private LocalStorage|MockObject $storage;

    public function setUp(): void
    {
        $this->ui = $this->getMockBuilder(CronUIInterface::class)->disableOriginalConstructor()->getMock();
        $this->logger = $this->getMockBuilder(LoggerInterface::class)->disableOriginalConstructor()->getMock();

        $this->fileRepository = $this->getMockBuilder(FileRepository::class)->disableOriginalConstructor()->getMock();
        $this->connection = $this->getMockBuilder(Connection::class)->disableOriginalConstructor()->getMock();
        $this->storage = $this->getMockBuilder(LocalStorage::class)->disableOriginalConstructor()->getMock();
    }

    private function getMockFor(string $method): MockObject | TestableCleanTempFile
    {
        $cleanTempFiles = $this->getMockBuilder(TestableCleanTempFile::class)
            ->setConstructorArgs([$this->connection, $this->fileRepository, $this->storage])
            ->setMethodsExcept([$method, 'setUI', 'setLoggerInterface'])
            ->getMock();
        $cleanTempFiles->setUI($this->ui);
        $cleanTempFiles->setLoggerInterface($this->logger);

        return $cleanTempFiles;
    }

    public function testPreview(): void
    {
        DatesUtils::setFakeDatetime('2022-01-08 00:00:00');
        $maxDate = DatesUtils::new();
        $maxDate->sub(new \DateInterval('P60D'));

        $cleanTempFiles = $this->getMockFor('preview');

        $file1 = $this->getMockBuilder(File::class)->getMock();
        $file1->method('getPath')->willReturn('/foo');

        $file2 = $this->getMockBuilder(File::class)->getMock();
        $file2->method('getPath')->willReturn('/bar');

        $file3 = $this->getMockBuilder(File::class)->getMock();
        $file3->method('getPath')->willReturn('/foo/bar');

        $cleanTempFiles->method('listFilesToDelete')->with($maxDate)->willReturn([$file1, $file2, $file3]);

        $this->ui->expects(self::atLeastOnce())->method('print')->withConsecutive(
            ['3 temporary files to be removed'],
            ['> Printing the first and last 50 :'],
            ['  * /foo'],
            ['  * /bar'],
            ['  * /foo/bar']
        );

        $cleanTempFiles->preview();
    }

    public function testExecute(): void
    {
        DatesUtils::setFakeDatetime('2022-01-08 00:00:00');
        $maxDate = DatesUtils::new();
        $maxDate->sub(new \DateInterval('P60D'));

        $cleanTempFiles = $this->getMockFor('execute');

        $files = [
            $this->getMockBuilder(File::class)->getMock(),
            $this->getMockBuilder(File::class)->getMock(),
            $this->getMockBuilder(File::class)->getMock(),
        ];

        $cleanTempFiles->method('listFilesToDelete')->with($maxDate)->willReturn($files);

        $cleanTempFiles->expects(self::once())->method('deleteFiles')->with($files);

        $cleanTempFiles->execute();
    }

    public function testListFilesToDelete(): void
    {
        $cleanTempFiles = $this->getMockFor('listFilesToDelete');

        DatesUtils::setFakeDatetime('2023-05-01 00:00:00');
        $maxDate = DatesUtils::new();

        // Mock la méthode getQueryBuilder()
        $queryBuilder = $this->getMockBuilder(QueryBuilder::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->fileRepository->method('createQueryBuilder')->with('f')->willReturn($queryBuilder);

        // S'attend à ce que la méthode select() soit appelée
        $queryBuilder->expects($this->once())
            ->method('select');

        // S'attend à ce que la méthode getQueryConditions() soit appelée avec $maxDate
        $cleanTempFiles->expects($this->once())
            ->method('getQueryConditions')
            ->with($queryBuilder, $maxDate);

        // Mock la méthode getQuery() et getResult() pour renvoyer un tableau vide
        $query = $this->getMockBuilder(AbstractQuery::class)
            ->disableOriginalConstructor()
            ->getMock();

        $query->expects($this->once())
            ->method('getResult')
            ->willReturn([]);

        $queryBuilder->expects($this->once())
            ->method('getQuery')
            ->willReturn($query);

        // Appeler la méthode listFilesToDelete()
        $result = $cleanTempFiles->listFilesToDelete($maxDate);

        // Vérifier que la méthode getResult() a été appelée sur la requête
        $this->assertEquals([], $result);
    }

    public function testDeleteFiles(): void {
        $cleanTempFiles = $this->getMockFor('deleteFiles');

        $file1 = $this->getMockBuilder(File::class)->getMock();
        $file1->method('getId')->willReturn(1);

        $file2 = $this->getMockBuilder(File::class)->getMock();
        $file2->method('getId')->willReturn(2);

        $file3 = $this->getMockBuilder(File::class)->getMock();
        $file3->method('getId')->willReturn(3);

        $files = [$file1, $file2, $file3];

        $this->connection->expects($this->once())->method('beginTransaction');
        $this->connection->expects($this->once())->method('setAutoCommit')->with(false);

        $queryBuilder = $this->getMockBuilder(QueryBuilder::class)->disableOriginalConstructor()->getMock();
        $this->fileRepository->expects($this->once())->method('createQueryBuilder')->with('f')->willReturn($queryBuilder);

        $queryBuilder
            ->expects(self::exactly(3))
            ->method('delete')
            ->willReturnSelf();

        $queryBuilder
            ->expects(self::exactly(3))
            ->method('delete')
            ->willReturnSelf();

        $queryBuilder
            ->expects(self::exactly(3))
            ->method('where')
            ->with('f.id = :id')
            ->willReturnSelf();

        $queryBuilder
            ->expects(self::exactly(3))
            ->method('setParameter')
            ->withConsecutive(['id', 1], ['id', 2], ['id', 3]);

        $this->storage
            ->expects(self::exactly(3))
            ->method('hardDelete')
            ->withConsecutive([$file1], [$file1], [$file3]);

        $this->connection->expects($this->once())->method('commit');

        $this->logger->expects(self::atLeastOnce())->method('info')->withConsecutive(
            ['3 temporary files to be removed'],
            ['Deleting files...'],
            ['3 files deleted']
        );

        $cleanTempFiles->deleteFiles($files);
    }
}