<?php

declare(strict_types=1);

namespace MeshVault\Tests\Unit\Indexer;

use MeshVault\Indexer\ImportException;
use MeshVault\Indexer\SpaceChecker;
use PHPUnit\Framework\TestCase;

final class SpaceCheckerTest extends TestCase
{
    public function testStructuredException(): void
    {
        self::assertTrue(class_exists(ImportException::class));
        $previous = new \RuntimeException('underlying');
        $error = new ImportException('DISK_FULL', 'Need more space', $previous);
        self::assertSame('DISK_FULL', $error->reason);
        self::assertSame('Need more space', $error->getMessage());
        self::assertSame($previous, $error->getPrevious());
        self::assertSame('DISK_FULL', (new ImportException('DISK_FULL'))->getMessage());
    }

    public function testDefaultAndCustomMargins(): void
    {
        self::assertTrue(class_exists(SpaceChecker::class));
        (new SpaceChecker(freeSpace: fn ($path) => 105.0))->check(__DIR__, 100);
        (new SpaceChecker(0.2, fn ($path) => 120.0))->check(__DIR__, 100);
        (new SpaceChecker(0.0, fn ($path) => 100.0))->check(__DIR__, 100);
        (new SpaceChecker())->check(__DIR__, 0);
        self::assertTrue(true);
    }

    public function testInsufficientUnknownAndThrownSpaceFailures(): void
    {
        self::assertTrue(class_exists(SpaceChecker::class));
        foreach ([104.0, false, -1.0, NAN, INF, 'throws'] as $free) {
            try {
                (new SpaceChecker(freeSpace: static function () use ($free) {
                    if ($free === 'throws') {
                        throw new \RuntimeException('disk query');
                    }
                    return $free;
                }))->check(__DIR__, 100);
                self::fail('Expected space error');
            } catch (ImportException $error) {
                self::assertSame($free === 104.0 ? 'DISK_FULL' : 'SPACE_CHECK_FAILED', $error->reason);
            }
        }
    }

    public function testInvalidMargins(): void
    {
        self::assertTrue(class_exists(SpaceChecker::class));
        foreach ([-0.01, INF, NAN] as $margin) {
            try {
                new SpaceChecker($margin);
                self::fail('Expected invalid margin');
            } catch (\InvalidArgumentException) {
                self::assertTrue(true);
            }
        }
    }

    public function testNegativeSize(): void
    {
        self::assertTrue(class_exists(SpaceChecker::class));
        $this->expectException(\InvalidArgumentException::class);
        (new SpaceChecker())->check(__DIR__, -1);
    }

    public function testMissingDirectoryFailsClosed(): void
    {
        self::assertTrue(class_exists(SpaceChecker::class));
        $this->expectException(ImportException::class);
        (new SpaceChecker())->check(__DIR__ . '/missing-space-directory', 1);
    }
}