<?php
declare(strict_types=1);
namespace PHPJava\Core;

use PHPJava\Core\JVM\Parameters\Runtime;
use PHPJava\Exceptions\UndefinedEntrypointException;
use PHPJava\Kernel\Internal\JavaInlineClassDeferredLoader;
use PHPJava\Kernel\Resolvers\ClassResolver;
use PHPJava\Kernel\Resolvers\FileTypeResolver;
use PHPJava\Packages\java\io\FileNotFoundException;
use PHPJava\Packages\java\lang\ClassNotFoundException;
use PHPJava\Utilities\DebugTool;

class JavaArchive
{
    const MANIFEST_FILE_NAME = 'META-INF/MANIFEST.MF';
    const DEFAULT_ENTRYPOINT_NAME = 'main';
    const IGNORE_FILES = [
        'META-INF/main.kotlin_module',
    ];

    /**
     * @var ?string[]
     */
    private $manifestData = [];

    /**
     * @var string
     */
    private $jarFile;

    /**
     * @var \ZipArchive
     */
    private $expandedHArchive;

    /**
     * @var string[]
     */
    private $files = [];

    /**
     * @var JavaClassInterface
     */
    private $classes = [];

    /**
     * @var array
     */
    private $options = [];

    /**
     * @var DebugTool
     */
    private $debugTool;

    /**
     * @var float
     */
    private $startTime = 0.0;

    /**
     * @throws FileNotFoundException
     * @throws \PHPJava\Exceptions\ReadEntryException
     * @throws \PHPJava\Exceptions\ValidatorException
     * @throws \PHPJava\Packages\java\lang\ClassNotFoundException
     */
    public function __construct(string $jarFile, array $options = [])
    {
        $this->startTime = microtime(true);
        $this->jarFile = $jarFile;
        $archive = new \ZipArchive();
        $archive->open($jarFile);
        $this->expandedHArchive = $archive;
        $this->options = $options;
        $this->debugTool = new DebugTool(
            basename($jarFile),
            $this->options
        );

        $this->debugTool->getLogger()->info('Start jar emulation');

        $this->manifestData['main-class'] = $options['entrypoint'] ?? Runtime::ENTRYPOINT;

        // Add resolving path
        ClassResolver::add(
            [
                [ClassResolver::RESOURCE_TYPE_FILE, dirname($jarFile)],
                [ClassResolver::RESOURCE_TYPE_FILE, getcwd()],
                [ClassResolver::RESOURCE_TYPE_JAR, $this],
            ]
        );

        $this->debugTool->getLogger()->debug('Extracting jar files: ' . $this->expandedHArchive->numFiles);
        for ($i = 0; $i < $this->expandedHArchive->numFiles; $i++) {
            $name = $archive->getNameIndex($i);
            if ($name[strlen($name) - 1] === '/') {
                continue;
            }
            $fileName = preg_replace('/\.class$/', '', $name);
            $this->files[$fileName] = $archive->getFromIndex($i);
        }

        if (!isset($this->files[static::MANIFEST_FILE_NAME])) {
            throw new FileNotFoundException('Failed to load Manifest.mf');
        }

        foreach (explode("\n", $this->files[static::MANIFEST_FILE_NAME]) as $attribute) {
            $attribute = str_replace(["\r", "\n"], '', $attribute);
            if (empty($attribute)) {
                continue;
            }
            if (strpos($attribute, ':') === false) {
                continue;
            }
            [$name, $value] = explode(':', $attribute);
            $this->manifestData[strtolower($name)] = trim($value);
        }

        $this->files = array_filter(
            $this->files,
            function ($fileName) {
                return $fileName !== static::MANIFEST_FILE_NAME;
            },
            ARRAY_FILTER_USE_KEY
        );

        foreach ($this->files as $className => $code) {
            if (in_array($className, static::IGNORE_FILES)) {
                continue;
            }
            $classPath = str_replace('/', '.', $className);
            $this->classes[$classPath] = new JavaInlineClassDeferredLoader(
                [$className, $code],
                $this->options
            );
        }

        $currentDirectory = getcwd();
        foreach ($this->getClassPaths() as $classPath) {
            $resolvePath = $classPath[0] === '/' ? $classPath : ($currentDirectory . '/' . $classPath);
            $realpath = realpath($resolvePath);
            if ($realpath === false) {
                throw new FileNotFoundException($classPath . ' does not exist.');
            }

            $value = $realpath;

            switch ($fileType = FileTypeResolver::resolve($resolvePath)) {
                case ClassResolver::RESOURCE_TYPE_CLASS:
                    $value = new JavaCompiledClass(
                        new Stream\Reader\FileReader($value),
                        $this->options
                    );
                    break;
                case ClassResolver::RESOURCE_TYPE_JAR:
                    $value = new JavaArchive($value, $this->options);
                    break;
                case ClassResolver::RESOURCE_TYPE_FILE:
                    break;
            }
            ClassResolver::add($fileType, $value);
        }

        $this->debugTool->getLogger()->info('End of jar');
    }

    public function __destruct()
    {
        $this->debugTool->getLogger()->info(
            'Spent time: ' . (microtime(true) - $this->startTime) . ' sec.'
        );
    }

    /**
     * @throws ClassNotFoundException
     * @throws UndefinedEntrypointException
     */
    public function execute(...$arguments)
    {
        $this->debugTool->getLogger()->info('Call to entrypoint: ' . $this->getEntryPointName());
        if ($this->getEntryPointName() === null) {
            throw new UndefinedEntrypointException('No entrypoint.');
        }
        return $this
            ->getClassByName($this->getEntryPointName())
            ->getInvoker()
            ->getStatic()
            ->getMethods()
            ->call(
                static::DEFAULT_ENTRYPOINT_NAME,
                ...$arguments
            );
    }

    /**
     * @return mixed[]
     */
    public function __debugInfo()
    {
        return [
            'version' => $this->getVersion(),
            'createdBy' => $this->getCreatedBy(),
            'entryPointName' => $this->getEntryPointName(),
            'file' => $this->jarFile,
            'classes' => $this->getClasses(),
            'classPaths' => $this->getClassPaths(),
        ];
    }

    public function getVersion(): ?string
    {
        return $this->manifestData['manifest-version'] ?? null;
    }

    public function getCreatedBy(): ?string
    {
        return $this->manifestData['created-by'] ?? null;
    }

    public function getEntryPointName(): ?string
    {
        return $this->manifestData['main-class'] ?? null;
    }

    /**
     * @return string[]
     */
    public function getClassPaths(): array
    {
        $classPaths = [];
        foreach (explode(' ', $this->manifestData['class-path'] ?? '') as $path) {
            if (empty($path)) {
                continue;
            }
            $classPaths[] = $path;
        }
        return $classPaths;
    }

    /**
     * @return JavaClassInterface[]
     */
    public function getClasses(): array
    {
        return $this->classes;
    }

    public function getClassByName(string $name): JavaClassInterface
    {
        $name = str_replace('/', '.', $name);
        if (!isset($this->classes[$name])) {
            throw new ClassNotFoundException($name . ' does not exist on ' . $this->jarFile . '.');
        }
        return $this->classes[$name];
    }
}