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

use PHPJava\Core\Extended\Classifiable;
use PHPJava\Core\Extended\ClassInvokable;
use PHPJava\Core\Extended\Debuggable;
use PHPJava\Core\Extended\Finalizable;
use PHPJava\Core\Extended\InvokerProvidable;
use PHPJava\Core\Extended\OptionExtendable;
use PHPJava\Core\JVM\AttributePool;
use PHPJava\Core\JVM\ClassInvokerInterface;
use PHPJava\Core\JVM\ConstantPool;
use PHPJava\Core\JVM\FieldPool;
use PHPJava\Core\JVM\InterfacePool;
use PHPJava\Core\JVM\JavaClassInvoker;
use PHPJava\Core\JVM\MethodPool;
use PHPJava\Core\JVM\Validations\MagicByte;
use PHPJava\Core\Stream\Reader\ReaderInterface;
use PHPJava\Exceptions\ValidatorException;
use PHPJava\Kernel\Attributes\AttributeInfo;
use PHPJava\Kernel\Attributes\InnerClassesAttribute;
use PHPJava\Kernel\Resolvers\ClassResolver;
use PHPJava\Kernel\Resolvers\SDKVersionResolver;
use PHPJava\Kernel\Structures\InnerClasses;
use PHPJava\Kernel\Structures\MethodInfo;
use PHPJava\Kernel\Structures\Utf8Info;
use PHPJava\Utilities\DebugTool;
use PHPJava\Utilities\Formatter;

class JavaCompiledClass implements JavaGenericClassInterface, JavaClassInterface
{
    use \PHPJava\Kernel\Core\ConstantPool;
    use Classifiable;
    use Debuggable;
    use OptionExtendable;
    use Finalizable;
    use ClassInvokable;
    use InvokerProvidable;

    /**
     * @var int[]
     */
    private $versions = [
        'minor' => null,
        'major' => null,
    ];

    /**
     * @var InterfacePool
     */
    private $interfacePool;

    /**
     * @var FieldPool
     */
    private $fieldPool;

    /**
     * @var MethodPool
     */
    private $methodPool;

    /**
     * @var AttributePool
     */
    private $attributePool;

    /**
     * @var int
     */
    private $accessFlag = 0;

    /**
     * @var int
     */
    private $thisClass = 0;

    /**
     * @var int
     */
    private $superClassIndex = 0;

    /**
     * @var null|Utf8Info
     */
    private $className;

    /**
     * @var JavaClassInvoker
     */
    private $invoker;

    /**
     * @var PHPJava\Kernel\Structures\_Classes[]
     */
    private $innerClasses = [];

    /**
     * @var mixed
     */
    private $superClass;

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

    /**
     * @throws ValidatorException
     * @throws \PHPJava\Exceptions\ReadEntryException
     * @throws \PHPJava\Exceptions\UnknownVersionException
     */
    public function __construct(ReaderInterface $reader, array $options = [])
    {
        $this->startTime = microtime(true);

        // Validate Java file
        if (!(new MagicByte($reader->getReader()->readUnsignedInt()))->isValid()) {
            throw new ValidatorException($reader . ' has broken or not Java class.');
        }

        // options
        $this->options = $options;

        ClassResolver::add([
            [ClassResolver::RESOURCE_TYPE_FILE, dirname($reader->getFileName())],
            [ClassResolver::RESOURCE_TYPE_FILE, getcwd()],
        ]);

        // Debug tool
        $this->debugTool = new DebugTool(
            $reader->getJavaPathName(),
            $options
        );

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

        // read minor version
        $this->versions['minor'] = $reader->getReader()->readUnsignedShort();

        $this->debugTool->getLogger()->info('Minor version: ' . $this->versions['minor']);

        // read major version
        $this->versions['major'] = $reader->getReader()->readUnsignedShort();

        $this->debugTool->getLogger()->info('Major version: ' . $this->versions['major']);

        $this->debugTool->getLogger()->info('JDK version: ' . SDKVersionResolver::resolve($this->versions['major'] . '.' . $this->versions['minor']));

        // read constant pool size
        $this->constantPool = new ConstantPool(
            $reader,
            $reader->getReader()->readUnsignedShort()
        );

        $this->debugTool->getLogger()->info('Constant Pools: ' . count($this->constantPool));

        // read access flag
        $this->accessFlag = $reader->getReader()->readUnsignedShort();

        // read this class
        $this->thisClass = $reader->getReader()->readUnsignedShort();

        $this->className = $this->constantPool[$this->constantPool[$this->thisClass]->getClassIndex()];

        // read super class
        $this->superClassIndex = $reader->getReader()->readUnsignedShort();

        $cpInfo = $this->getConstantPool();

        $this->superClass = JavaClass::load(
            $cpInfo[$cpInfo[$this->superClassIndex]->getClassIndex()]->getString(),
            $this->options
        );

        $this->debugTool->getLogger()->info(
            'Load super class: ' . $this->superClass->getClassName()
        );

        // read interfaces
        $this->interfacePool = new InterfacePool(
            $reader,
            $reader->getReader()->readUnsignedShort(),
            $this->constantPool,
            $this->debugTool
        );

        $this->debugTool->getLogger()->info('Extracted interfaces: ' . count($this->interfacePool));

        // read fields
        $this->fieldPool = new FieldPool(
            $reader,
            $reader->getReader()->readUnsignedShort(),
            $this->constantPool,
            $this->debugTool
        );

        $this->debugTool->getLogger()->info('Extracted fields: ' . count($this->fieldPool));

        // read methods
        $this->methodPool = new MethodPool(
            $reader,
            $reader->getReader()->readUnsignedShort(),
            $this->constantPool,
            $this->debugTool
        );

        $this->debugTool->getLogger()->info('Extracted methods: ' . count($this->methodPool));

        // read Attributes
        $this->attributePool = new AttributePool(
            $reader,
            $reader->getReader()->readUnsignedShort(),
            $this->constantPool,
            $this->debugTool
        );

        $this->debugTool->getLogger()->info('Extracted attributes: ' . count($this->attributePool));

        $this->debugTool->getLogger()->info('Load inner classes');

        $innerClasses = [];
        foreach ($this->attributePool as $entry) {
            /**
             * @var AttributeInfo $entry
             */
            if ($entry->getAttributeData() instanceof InnerClassesAttribute) {
                /**
                 * @var InnerClassesAttribute $attributeData
                 */
                $attributeData = $entry->getAttributeData();
                foreach ($attributeData->getClasses() as $innerClassInfo) {
                    /**
                     * @var InnerClasses $innerClassInfo
                     */
                    $info = $this->constantPool[$innerClassInfo->getInnerClassInfoIndex()];
                    $className = $this->constantPool[$info->getClassIndex()]->getString();

                    $innerClasses[] = [
                        JavaClass::deferred(
                            $className,
                            $this->options
                        ),
                        $innerClassInfo,
                        $this->constantPool,
                    ];
                }
            }
        }

        $this->innerClasses = $innerClasses;

        $this->debugTool->getLogger()->info('Loaded inner classes');

        $this->invoker = new JavaClassInvoker(
            $this,
            $options
        );

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

    public function __debugInfo()
    {
        $superClass = $this->getSuperClass();
        return [
            'JDKVersion' => SDKVersionResolver::resolve($this->versions['major'] . '.' . $this->versions['minor']),
            'name' => str_replace('/', '.', $this->getClassName()),
            'super' => str_replace('/', '.', $this->getSuperClass() ? $this->getSuperClass()->getClassName() : null),
            'methods' => array_map(
                function (MethodInfo $method) {
                    return Formatter::beatifyMethodFromConstantPool(
                        $method,
                        $this->constantPool
                    );
                },
                $this->methodPool->getEntries()
            ),
        ];
    }

    public function getClassName(bool $shortName = false): string
    {
        $className = $this->className->getString();
        if ($shortName === true) {
            $split = explode('$', $className);
            return $split[count($split) - 1];
        }
        return $className;
    }

    public function getPackageName(): ?string
    {
        $className = dirname($this->className->getString());
        if ($className === '') {
            return null;
        }
        return str_replace('/', '.', $className);
    }

    /**
     * @return PHPJava\Core\JVM\FieldInfo[]
     */
    public function getDefinedFields(): array
    {
        return $this->fieldPool->getEntries();
    }

    /**
     * @return PHPJava\Core\JVM\MethodInfo[]
     */
    public function getDefinedMethods(): array
    {
        return $this->methodPool->getEntries();
    }

    public function getDefinedExtendedClasses(): array
    {
        $parents = [];
        $currentClassObject = $this;
        while ($parentClass = $currentClassObject->getSuperClass()) {
            $parents[] = Formatter::convertPHPNamespacesToJava($parentClass->getClassName());
            $currentClassObject = $parentClass;
        }
        $parents[] = Formatter::convertPHPNamespacesToJava($this->getClassName());
        return $parents;
    }

    public function getDefinedInnerClasses(): array
    {
        return $this->innerClasses;
    }

    public function getDefinedInterfaceClasses(): array
    {
        return $this->interfacePool->getEntries();
    }

    public function getInvoker(): ClassInvokerInterface
    {
        return $this->invoker;
    }

    public function getSuperClass()
    {
        return $this->superClass;
    }

    /**
     * @return PHPJava\Core\JVM\_AttributeInfo[]
     */
    public function getAttributes(): array
    {
        return $this->attributePool->getEntries();
    }
}