<?php

declare(strict_types=1);

namespace Bfabio\PublicCodeParser;

use Bfabio\PublicCodeParser\Exception\ParserException;
use Bfabio\PublicCodeParser\Exception\ValidationException;
use FFI;

class Parser
{
    private ParserConfig $config;
    private FFI $ffi;
    private static ?FFI $ffiInstance = null;
    private int $handle;

    public function __construct(?ParserConfig $config = null)
    {
        $this->config = $config ?? new ParserConfig();

        $this->ffi = $this->getFFI();
        /** @phpstan-ignore-next-line */
        $this->handle = $this->ffi->NewParser(
            $this->config->isNetworkDisabled(),
            $this->config->areExternalChecksDisabled(),
            $this->config->getBranch(),
            $this->config->getBaseURL(),
            $this->config->getHTTPTimeout() * 1_000_000_000,
        );
        if ($this->handle == 0) {
            throw new ParserException('Failed to create parser');
        }
    }

    public function __destruct()
    {
        if ($this->handle != 0) {
            /** @phpstan-ignore-next-line */
            $this->ffi->FreeParser($this->handle);
            $this->handle = 0;
        }
    }

    /**
     * Parse publiccode.yml content
     *
     * @param string $content YAML content
     * @return PublicCodeV0
     * @throws ParserException
     * @throws ValidationException
     */
    public function parse(string $content): PublicCodeV0
    {
        /** @phpstan-ignore-next-line */
        $result = $this->ffi->ParseString($this->handle, $content);

        if ($result === null) {
            throw new ParserException('Failed to parse publiccode.yml content');
        }

        return $this->processResult($result);
    }

    /**
     * Parse a publiccode.yml file
     *
     * @param string $filePath Path to publiccode.yml
     * @return PublicCodeV0
     * @throws ParserException
     * @throws ValidationException
     */
    public function parseFile(string $filePath): PublicCodeV0
    {
        /** @phpstan-ignore-next-line */
        $result = $this->ffi->ParseFile($this->handle, $filePath);

        if ($result === null) {
            throw new ParserException("Failed to parse $filePath");
        }

        return $this->processResult($result);
    }

    /**
     * Helper function to validate publiccode.yml file, with no error details
     *
     * @param string $filePath
     * @return bool
     */
    public function isValid(string $filePath): bool
    {
        try {
            $this->parseFile($filePath);
            return true;
        } catch (ParserException | ValidationException $e) {
            return false;
        }
    }

    /**
     * Get or create FFI instance
     *
     * @return FFI
     * @throws ParserException
     */
    private function getFFI(): FFI
    {
        if (self::$ffiInstance !== null) {
            return self::$ffiInstance;
        }

        $libraryPath = $this->findLibrary();

        $cdef = <<<'CDEF'
	typedef struct {
	    char* Data;
	    char* Error;
	    int ErrorCount;
	    char** Errors;
	    int WarningCount;
	    char** Warnings;
	} ParseResult;

	typedef uintptr_t ParserHandle;

	ParserHandle NewParser(bool disableNetwork, bool disableExternalChecks, const char* branch, const char* baseURL, int64_t httpTimeout);
	ParseResult* ParseString(ParserHandle handle, const char* content);
	ParseResult* ParseFile(ParserHandle handle, const char* uri);
	void FreeResult(ParseResult* result);
	void FreeParser(ParserHandle handle);
	CDEF;

        try {
            self::$ffiInstance = FFI::cdef($cdef, $libraryPath);
            return self::$ffiInstance;
        } catch (\FFI\Exception $e) {
            throw new ParserException(
                'Failed to load publiccode-parser library: ' . $e->getMessage(),
                0,
                $e,
            );
        }
    }

    /**
     * Find the publiccode-parser shared library
     *
     * @return string
     * @throws ParserException
     */
    private function findLibrary(): string
    {
        $os = $this->detectOS();
        $arch = $this->detectArchitecture();
        $ext = $os === 'darwin' ? 'dylib' : 'so';

        $libraryName = "libpubliccode-parser-{$os}-{$arch}.{$ext}";

        $possiblePaths = [
            __DIR__ . '/',
            __DIR__ . '/../lib/',
            __DIR__ . '/../vendor/lib/',
            '/usr/local/lib/',
            '/usr/lib/',
        ];

        foreach ($possiblePaths as $path) {
            $filePath = $path . $libraryName;
            if (file_exists($filePath)) {
                return $filePath;
            }
        }

        throw new ParserException(
            "libpubliccode-parser library not found for platform: {$os}-{$arch}. " .
                "Searched for: {$libraryName}",
        );
    }

    /**
     * Detect operating system
     *
     * @return 'linux'|'darwin'
     * @throws ParserException
     */
    private function detectOS(): string
    {
        $osFamily = PHP_OS_FAMILY;

        if ($osFamily === 'Linux') {
            return 'linux';
        }

        if ($osFamily === 'Darwin') {
            return 'darwin';
        }

        throw new ParserException("Unsupported operating system: {$osFamily}");
    }

    /**
     * Detect CPU architecture
     *
     * @return 'amd64'|'arm64'
     * @throws ParserException
     */
    private function detectArchitecture(): string
    {
        $machine = php_uname('m');

        if (in_array($machine, ['x86_64', 'amd64', 'AMD64'], true)) {
            return 'amd64';
        }

        if (in_array($machine, ['arm64', 'aarch64', 'ARM64'], true)) {
            return 'arm64';
        }

        throw new ParserException("Unsupported architecture: {$machine}");
    }

    /**
     * Process FFI result and convert to PublicCode object
     *
     * @param mixed $result FFI ParseResult pointer
     * @return PublicCodeV0
     * @throws ValidationException
     * @throws ParserException
     */
    private function processResult($result): PublicCodeV0
    {
        [$warnings, $validationWarnings] = $this->parseValidationWarnings(
            $result->Warnings,
            $result->WarningCount,
        );

        if ($result->ErrorCount > 0) {
            [$errors, $validationErrors] = $this->parseValidationErrors(
                $result->Errors,
                $result->ErrorCount,
            );

            /** @phpstan-ignore-next-line */
            $this->ffi->FreeResult($result);

            throw new ValidationException(
                message: implode("\n", $errors),
                errors: $errors,
                validationErrors: $validationErrors,
                warnings: $warnings,
                validationWarnings: $validationWarnings,
            );
        }

        if ($result->Error !== null) {
            $message = FFI::string($result->Error);
            /** @phpstan-ignore-next-line */
            $this->ffi->FreeResult($result);

            throw new ParserException($message);
        }

        if ($result->Data === null) {
            /** @phpstan-ignore-next-line */
            $this->ffi->FreeResult($result);

            throw new ParserException('No data returned from parser');
        }

        $jsonData = FFI::string($result->Data);
        /** @phpstan-ignore-next-line */
        $this->ffi->FreeResult($result);

        $data = json_decode($jsonData, true);

        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new ParserException('Failed to decode JSON data: ' . json_last_error_msg());
        }

        return new PublicCodeV0($data, $warnings, $validationWarnings);
    }

    /**
     * @param mixed $cArray FFI pointer to char** (may be null)
     * @return array{list<string>, list<ValidationError>}
     */
    private function parseValidationErrors($cArray, int $count): array
    {
        $messages = [];
        $errors = [];

        if ($cArray === null || $count === 0) {
            return [$messages, $errors];
        }

        for ($i = 0; $i < $count; $i++) {
            $payload = FFI::string($cArray[$i]);
            $data = json_decode($payload, true);

            if (is_array($data)) {
                $error = ValidationError::fromArray($data);
                $messages[] = (string) $error;
            } else {
                $error = ValidationError::fromString($payload);
                $messages[] = $payload;
            }

            $errors[] = $error;
        }

        return [$messages, $errors];
    }

    /**
     * @param mixed $cArray FFI pointer to char** (may be null)
     * @return array{list<string>, list<ValidationWarning>}
     */
    private function parseValidationWarnings($cArray, int $count): array
    {
        $messages = [];
        $warnings = [];

        if ($cArray === null || $count === 0) {
            return [$messages, $warnings];
        }

        for ($i = 0; $i < $count; $i++) {
            $payload = FFI::string($cArray[$i]);
            $data = json_decode($payload, true);

            if (is_array($data)) {
                $warning = ValidationWarning::fromArray($data);
                $messages[] = (string) $warning;
            } else {
                $warning = ValidationWarning::fromString($payload);
                $messages[] = $payload;
            }

            $warnings[] = $warning;
        }

        return [$messages, $warnings];
    }
}