<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\VarDumper\Tests\Caster;

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\RequiresPhpExtension;
use PHPUnit\Framework\TestCase;
use Symfony\Component\VarDumper\Caster\FFICaster;
use Symfony\Component\VarDumper\Test\VarDumperTestTrait;

/**
 * @author Kirill Nesmeyanov <nesk@xakep.ru>
 */
#[RequiresPhpExtension('ffi')]
class FFICasterTest extends TestCase
{
    use VarDumperTestTrait;

    /**
     * @see FFICaster::MAX_STRING_LENGTH
     */
    private const MAX_STRING_LENGTH = 255;

    protected function setUp(): void
    {
        if (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) && 'preload' === \ini_get('ffi.enable')) {
            return;
        }
        if (!filter_var(\ini_get('ffi.enable'), \FILTER_VALIDATE_BOOL)) {
            $this->markTestSkipped('FFI not enabled for CLI SAPI');
        }
    }

    public function testCastAnonymousStruct()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<struct <anonymous>> size 4 align 4 {
              uint32_t x: 0
            }
            PHP,
            \FFI::cdef()->new('struct { uint32_t x; }')
        );
    }

    public function testCastNamedStruct()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<struct Example> size 4 align 4 {
              uint32_t x: 0
            }
            PHP,
            \FFI::cdef()->new('struct Example { uint32_t x; }')
        );
    }

    public function testCastAnonymousUnion()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<union <anonymous>> size 4 align 4 {
              uint32_t x: 0
              uint32_t y: 0
            }
            PHP,
            \FFI::cdef()->new('union { uint32_t x; uint32_t y; }')
        );
    }

    public function testCastNamedUnion()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<union Example> size 4 align 4 {
              uint32_t x: 0
              uint32_t y: 0
            }
            PHP,
            \FFI::cdef()->new('union Example { uint32_t x; uint32_t y; }')
        );
    }

    public function testCastAnonymousEnum()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<enum <anonymous>> size 4 align 4 {
              cdata: 0
            }
            PHP,
            \FFI::cdef()->new('enum { a, b }')
        );
    }

    public function testCastNamedEnum()
    {
        $this->assertDumpEquals(<<<'PHP'
            FFI\CData<enum Example> size 4 align 4 {
              cdata: 0
            }
            PHP,
            \FFI::cdef()->new('enum Example { a, b }')
        );
    }

    public static function scalarsDataProvider(): array
    {
        return [
            'int8_t' => ['int8_t', '0', 1, 1],
            'uint8_t' => ['uint8_t', '0', 1, 1],
            'int16_t' => ['int16_t', '0', 2, 2],
            'uint16_t' => ['uint16_t', '0', 2, 2],
            'int32_t' => ['int32_t', '0', 4, 4],
            'uint32_t' => ['uint32_t', '0', 4, 4],
            // 'int64_t' => ['int64_t', '0', 8, 8],
            // 'uint64_t' => ['uint64_t', '0', 8, 8],

            'bool' => ['bool', 'false', 1, 1],
            'char' => ['char', '"\x00"', 1, 1],
            'float' => ['float', '0.0', 4, 4],
            // 'double' => ['double', '0.0', 8, 8],
        ];
    }

    #[DataProvider('scalarsDataProvider')]
    public function testCastScalar(string $type, string $value, int $size, int $align)
    {
        $this->assertDumpEquals(<<<PHP
            FFI\CData<$type> size $size align $align {
              cdata: $value
            }
            PHP,
            \FFI::cdef()->new($type)
        );
    }

    public function testCastVoidFunction()
    {
        self::markTestSkipped('Failing test (different output) on various architectures');

        $abi = \PHP_OS_FAMILY === 'Windows' ? '[cdecl]' : '[fastcall]';

        $this->assertDumpEquals(<<<PHP
            $abi callable(): void {
              returnType: FFI\CType<void> size 1 align 1 {}
            }
            PHP,
            \FFI::cdef()->new('void (*)(void)')
        );
    }

    public function testCastIntFunction()
    {
        self::markTestSkipped('Failing test (different output) on various architectures');

        $abi = \PHP_OS_FAMILY === 'Windows' ? '[cdecl]' : '[fastcall]';

        $this->assertDumpEquals(<<<PHP
            $abi callable(): uint64_t {
              returnType: FFI\CType<uint64_t> size 8 align 8 {}
            }
            PHP,
            \FFI::cdef()->new('unsigned long long (*)(void)')
        );
    }

    public function testCastFunctionWithArguments()
    {
        self::markTestSkipped('Failing test (different output) on various architectures');

        $abi = \PHP_OS_FAMILY === 'Windows' ? '[cdecl]' : '[fastcall]';

        $this->assertDumpEquals(<<<PHP
            $abi callable(int32_t, char*): void {
              returnType: FFI\CType<void> size 1 align 1 {}
            }
            PHP,
            \FFI::cdef()->new('void (*)(int a, const char* b)')
        );
    }

    public function testCastNonCuttedPointerToChar()
    {
        $actualMessage = "Hello World!\0";

        $string = \FFI::cdef()->new('char[100]');
        $pointer = \FFI::addr($string[0]);
        \FFI::memcpy($pointer, $actualMessage, \strlen($actualMessage));
        $size = \PHP_INT_SIZE;

        $this->assertDumpMatchesFormat(<<<PHP
            FFI\CData<char*> size $size align $size {
              cdata: "Hello World!%A"
            }
            PHP,
            $pointer
        );
    }

    public function testCastCuttedPointerToChar()
    {
        $actualMessage = str_repeat('Hello World!', 30)."\0";
        $actualLength = \strlen($actualMessage);
        $expectedMessage = substr($actualMessage, 0, self::MAX_STRING_LENGTH);

        $string = \FFI::cdef()->new('char['.$actualLength.']');
        $pointer = \FFI::addr($string[0]);
        \FFI::memcpy($pointer, $actualMessage, $actualLength);

        // the max length is platform-dependent and can be less than 255,
        // so we need to cut the expected message to the maximum length
        // allowed by pages size of the current system
        $ffi = \FFI::cdef(<<<C
                size_t zend_get_page_size(void);
            C
        );

        $pageSize = $ffi->zend_get_page_size();
        $start = $ffi->cast('uintptr_t', $ffi->cast('char*', $pointer))->cdata;
        $max = min(self::MAX_STRING_LENGTH, ($start | ($pageSize - 1)) - $start);
        $expectedMessage = substr($expectedMessage, 0, $max);
        $size = \PHP_INT_SIZE;

        $this->assertDumpEquals(<<<PHP
            FFI\CData<char*> size $size align $size {
              cdata: "$expectedMessage"…
            }
            PHP,
            $pointer
        );
    }

    public function testCastNonTrailingCharPointer()
    {
        $actualMessage = 'Hello World!';
        $actualLength = \strlen($actualMessage);

        $string = \FFI::cdef()->new('char['.($actualLength + 1).']');
        $pointer = \FFI::addr($string[0]);
        \FFI::memcpy($pointer, $actualMessage, $actualLength);

        $pointer = \FFI::cdef()->cast('char*', \FFI::cdef()->cast('void*', $pointer));
        $pointer[$actualLength] = "\x01";
        $size = \PHP_INT_SIZE;

        $this->assertDumpMatchesFormat(<<<PHP
            FFI\CData<char*> size $size align $size {
              cdata: %A"$actualMessage%s"
            }
            PHP,
            $pointer
        );
    }

    public function testCastUnionWithDirectReferencedFields()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef union Event {
                int32_t x;
                float y;
            } Event;
            CPP
        );

        $this->assertDumpEquals(<<<'OUTPUT'
            FFI\CData<union Event> size 4 align 4 {
              int32_t x: 0
              float y: 0.0
            }
            OUTPUT,
            $ffi->new('Event')
        );
    }

    public function testCastUnionWithPointerReferencedFields()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef union Event {
                void* something;
                char* string;
            } Event;
            CPP
        );
        $size = \PHP_INT_SIZE;

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<union Event> size $size align $size {
              something?: FFI\CType<void*> size $size align $size {
                0: FFI\CType<void> size 1 align 1 {}
              }
              string?: FFI\CType<char*> size $size align $size {
                0: FFI\CType<char> size 1 align 1 {}
              }
            }
            OUTPUT,
            $ffi->new('Event')
        );
    }

    public function testCastUnionWithMixedFields()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef union Event {
                void* a;
                int32_t b;
                char* c;
                ptrdiff_t d;
            } Event;
            CPP
        );
        $size = \PHP_INT_SIZE;
        $intt = \PHP_INT_SIZE === 4 ? 'int32_t' : 'int64_t';

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<union Event> size $size align $size {
              a?: FFI\CType<void*> size $size align $size {
                0: FFI\CType<void> size 1 align 1 {}
              }
              int32_t b: 0
              c?: FFI\CType<char*> size $size align $size {
                0: FFI\CType<char> size 1 align 1 {}
              }
              $intt d: 0
            }
            OUTPUT,
            $ffi->new('Event')
        );
    }

    public function testCastPointerToEmptyScalars()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef struct {
                int8_t *a;
                uint8_t *b;
                int64_t *c;
                uint64_t *d;
                float *e;
                double *f;
                bool *g;
            } Example;
            CPP
        );
        $size = \PHP_INT_SIZE === 4 ? 28 : 56;
        $isize = \PHP_INT_SIZE;

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<struct <anonymous>> size $size align $isize {
              int8_t* a: null
              uint8_t* b: null
              int64_t* c: null
              uint64_t* d: null
              float* e: null
              double* f: null
              bool* g: null
            }
            OUTPUT,
            $ffi->new('Example')
        );
    }

    public function testCastPointerToNonEmptyScalars()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef struct {
                int8_t *a;
                uint8_t *b;
                int64_t *c;
                uint64_t *d;
                float *e;
                double *f;
                bool *g;
            } Example;
            CPP
        );

        // Create values
        $int = \FFI::cdef()->new('int64_t');
        $int->cdata = 42;
        $float = \FFI::cdef()->new('float');
        $float->cdata = 42.0;
        $double = \FFI::cdef()->new('double');
        $double->cdata = 42.2;
        $bool = \FFI::cdef()->new('bool');
        $bool->cdata = true;

        // Fill struct
        $struct = $ffi->new('Example');
        $struct->a = \FFI::addr(\FFI::cdef()->cast('int8_t', $int));
        $struct->b = \FFI::addr(\FFI::cdef()->cast('uint8_t', $int));
        $struct->c = \FFI::addr(\FFI::cdef()->cast('int64_t', $int));
        $struct->d = \FFI::addr(\FFI::cdef()->cast('uint64_t', $int));
        $struct->e = \FFI::addr(\FFI::cdef()->cast('float', $float));
        $struct->f = \FFI::addr(\FFI::cdef()->cast('double', $double));
        $struct->g = \FFI::addr(\FFI::cdef()->cast('bool', $bool));
        $size = \PHP_INT_SIZE === 4 ? 28 : 56;
        $isize = \PHP_INT_SIZE;

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<struct <anonymous>> size $size align $isize {
              a: FFI\CData<int8_t*> size $isize align $isize {
                cdata: 42
              }
              b: FFI\CData<uint8_t*> size $isize align $isize {
                cdata: 42
              }
              c: FFI\CData<int64_t*> size $isize align $isize {
                cdata: 42
              }
              d: FFI\CData<uint64_t*> size $isize align $isize {
                cdata: 42
              }
              e: FFI\CData<float*> size $isize align $isize {
                cdata: 42.0
              }
              f: FFI\CData<double*> size $isize align $isize {
                cdata: 42.2
              }
              g: FFI\CData<bool*> size $isize align $isize {
                cdata: true
              }
            }
            OUTPUT,
            $struct
        );
    }

    public function testCastPointerToStruct()
    {
        $ffi = \FFI::cdef(<<<'CPP'
            typedef struct {
                int8_t a;
            } Example;
            CPP
        );

        $struct = $ffi->new('Example', false);
        $size = \PHP_INT_SIZE;

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<struct <anonymous>*> size $size align $size {
              cdata: FFI\CData<struct <anonymous>> size 1 align 1 {
                int8_t a: 0
              }
            }
            OUTPUT,
            \FFI::addr($struct)
        );

        // Save the pointer as variable so that
        // it is not cleaned up by the GC
        $pointer = \FFI::addr($struct);

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<struct <anonymous>**> size $size align $size {
              cdata: FFI\CData<struct <anonymous>*> size $size align $size {
                cdata: FFI\CData<struct <anonymous>> size 1 align 1 {
                  int8_t a: 0
                }
              }
            }
            OUTPUT,
            \FFI::addr($pointer)
        );

        \FFI::free($struct);
    }

    public function testCastComplexType()
    {
        self::markTestSkipped('Failing test (different output) on various architectures');

        $ffi = \FFI::cdef(<<<'CPP'
            typedef struct {
                int x;
                int y;
            } Point;
            typedef struct Example {
                uint8_t a[32];
                long b;
                __extension__ union {
                    __extension__ struct {
                        short c;
                        long d;
                    };
                    struct {
                        Point point;
                        float e;
                    };
                };
                short f;
                bool g;
                int (*func)(
                    struct __sub *h
                );
            } Example;
            CPP
        );

        $var = $ffi->new('Example');
        $var->func = (static fn (object $p) => 42);

        $abi = \PHP_OS_FAMILY === 'Windows' ? '[cdecl]' : '[fastcall]';
        $longSize = \FFI::cdef()->type('long')->getSize();
        $longType = 8 === $longSize ? 'int64_t' : 'int32_t';
        $structSize = 56 + $longSize * 2;

        $this->assertDumpEquals(<<<OUTPUT
            FFI\CData<struct Example> size $structSize align 8 {
              a: FFI\CData<uint8_t[32]> size 32 align 1 {}
              $longType b: 0
              int16_t c: 0
              $longType d: 0
              point: FFI\CData<struct <anonymous>> size 8 align 4 {
                int32_t x: 0
                int32_t y: 0
              }
              float e: 0.0
              int16_t f: 0
              bool g: false
              func: $abi callable(struct __sub*): int32_t {
                returnType: FFI\CType<int32_t> size 4 align 4 {}
              }
            }
            OUTPUT,
            $var
        );
    }
}