<?php

namespace FG\Test\ASN1\Universal;

use FG\ASN1\Decoder\Decoder;
use FG\ASN1\ExplicitlyTaggedObject;
use FG\ASN1\Identifier;
use FG\ASN1\ImplicitlyTaggedObject;
use FG\ASN1\Universal\BitString;
use FG\ASN1\Universal\Boolean;
use FG\ASN1\Universal\Enumerated;
use FG\ASN1\Universal\GeneralizedTime;
use FG\ASN1\Universal\IA5String;
use FG\ASN1\Universal\Integer;
use FG\ASN1\Universal\NullObject;
use FG\ASN1\Universal\ObjectIdentifier;
use FG\ASN1\Universal\OctetString;
use FG\ASN1\Universal\PrintableString;
use FG\ASN1\Universal\Sequence;
use FG\ASN1\UnknownConstructedObject;
use FG\ASN1\UnknownObject;
use FG\Test\ASN1TestCase;

class DecoderTest extends ASN1TestCase
{
    /** @var Decoder */
    private $decoder;

    public function setUp(): void
    {
        $this->decoder = new Decoder();
    }

    /**
     * For the real parsing tests look in the test cases of each single ASn object.
     */
    public function testFromBinary()
    {
        /* @var BitString $parsedObject */
        $binaryData  = chr(Identifier::BITSTRING);
        $binaryData .= chr(0x03);
        $binaryData .= chr(0x00);
        $binaryData .= chr(0xFF);
        $binaryData .= chr(0xA0);

        $expectedObject = BitString::createFromHexString('FFA0');
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof BitString);
        $this->assertEquals($expectedObject, $parsedObject);
        $this->assertEquals($expectedObject->getNumberOfUnusedBits(), $parsedObject->getNumberOfUnusedBits());

        /* @var OctetString $parsedObject */
        $binaryData  = chr(Identifier::OCTETSTRING);
        $binaryData .= chr(0x02);
        $binaryData .= chr(0xFF);
        $binaryData .= chr(0xA0);

        $expectedObject = OctetString::createFromString(hex2bin('FFA0'));
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof OctetString);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var \FG\ASN1\Universal\Boolean $parsedObject */
        $binaryData  = chr(Identifier::BOOLEAN);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0xFF);

        $expectedObject = Boolean::create(true);
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof Boolean);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var Enumerated $parsedObject */
        $binaryData  = chr(Identifier::ENUMERATED);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0x03);

        $expectedObject = Enumerated::create(3);
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof Enumerated);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var IA5String $parsedObject */
        $string      = 'Hello Foo World!!!11EinsEins!1';
        $binaryData  = chr(Identifier::IA5_STRING);
        $binaryData .= chr(strlen($string));
        $binaryData .= $string;

        $expectedObject = IA5String::createFromString($string);
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof IA5String);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var \FG\ASN1\Universal\Integer $parsedObject */
        $binaryData  = chr(Identifier::INTEGER);
        $binaryData .= chr(0x01);
        $binaryData .= chr(123);

        $expectedObject = Integer::create(123);
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof Integer);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var \FG\ASN1\Universal\NullObject $parsedObject */
        $binaryData  = chr(Identifier::NULL);
        $binaryData .= chr(0x00);

        $expectedObject = NullObject::create();
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof NullObject);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var ObjectIdentifier $parsedObject */
        $binaryData  = chr(Identifier::OBJECT_IDENTIFIER);
        $binaryData .= chr(0x02);
        $binaryData .= chr(1 * 40 + 2);
        $binaryData .= chr(3);

        $expectedObject = ObjectIdentifier::create('1.2.3');
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof ObjectIdentifier);
        $this->assertEquals($expectedObject->getContent(), $parsedObject->getContent());

        /* @var PrintableString $parsedObject */
        $string      = 'This is a test string. ?()+,/';
        $binaryData  = chr(Identifier::PRINTABLE_STRING);
        $binaryData .= chr(strlen($string));
        $binaryData .= $string;

        $expectedObject = PrintableString::createFromString($string);
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof PrintableString);
        $this->assertEquals($expectedObject, $parsedObject);

        /* @var GeneralizedTime $parsedObject */
        $binaryData  = chr(Identifier::GENERALIZED_TIME);
        $binaryData .= chr(15);
        $binaryData .= '20120923202316Z';

        $expectedObject = GeneralizedTime::createFormDateTime(new \DateTime('2012-09-23 20:23:16'));
        $parsedObject   = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof GeneralizedTime);
        $this->assertEquals($expectedObject->getContent(), $parsedObject->getContent());

        /* @var Sequence $parsedObject */
        $binaryData  = chr(Identifier::IS_CONSTRUCTED | Identifier::SEQUENCE);
        $binaryData .= chr(0x06);
        $binaryData .= chr(Identifier::BOOLEAN);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0x00);
        $binaryData .= chr(Identifier::INTEGER);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0x03);

        $parsedObject = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof Sequence);
        $this->assertCount(2, $parsedObject->getChildren());

        /* @var ExplicitlyTaggedObject $parsedObject */
        $taggedObject = ExplicitlyTaggedObject::create(0x01, PrintableString::createFromString('Hello tagged world'));
        $binaryData   = $taggedObject->getBinary();
        $parsedObject = $this->decoder->fromBinary($binaryData);
        $this->assertTrue($parsedObject instanceof ExplicitlyTaggedObject);

        $binaryString = hex2bin('860103');
        $object = $this->decoder->fromBinary($binaryString);
        $this->assertInstanceOf(ImplicitlyTaggedObject::class, $object);

        //PRIVATE 16 Primitive
        $binaryString = hex2bin('D00103');
        $object = $this->decoder->fromBinary($binaryString);
        $this->assertInstanceOf(UnknownObject::class, $object);

        //PRIVATE 1 Constructed
        $binaryData = hex2bin('E1');
        $binaryData .= chr(0x06);
        $binaryData .= chr(Identifier::BOOLEAN);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0x00);
        $binaryData .= chr(Identifier::INTEGER);
        $binaryData .= chr(0x01);
        $binaryData .= chr(0x03);

        $object = $this->decoder->fromBinary($binaryData);
        $this->assertInstanceOf(UnknownConstructedObject::class, $object);

        // An unknown constructed object containing 2 integer children,
        // first 3 bytes are the identifier.
        $binaryData   = "\x3F\x81\x7F\x06".chr(Identifier::INTEGER)."\x01\x42".chr(Identifier::INTEGER)."\x01\x69";
        $offsetIndex  = 0;
        $parsedObject = $this->decoder->fromBinary($binaryData, $offsetIndex);
        $this->assertTrue($parsedObject instanceof UnknownConstructedObject);
        $this->assertEquals(substr($binaryData, 0, 3), $parsedObject->getIdentifier()->getBinary());
        $this->assertCount(2, $parsedObject->getChildren());
        $this->assertEquals(strlen($binaryData), $offsetIndex);
        $this->assertEquals(10, $parsedObject->getObjectLength());

        // First 3 bytes are the identifier
        $binaryData   = "\x1F\x81\x7F\x01\xFF";
        $offsetIndex  = 0;
        $parsedObject = $this->decoder->fromBinary($binaryData, $offsetIndex);
        $this->assertTrue($parsedObject instanceof UnknownObject);
        $this->assertEquals(substr($binaryData, 0, 3), $parsedObject->getIdentifier()->getBinary());
        $this->assertEquals(strlen($binaryData), $offsetIndex);
        $this->assertEquals(5, $parsedObject->getObjectLength());
    }

    public function testFromBinaryConstructedWithIndefiniteLength()
    {
        //Octet string with 2 octet strings inside
        $hex = '2480040d8dfff0980736af936e423acfcc04159277f7f0e479ffc7dc33b2d03d7b1a186d4472aa490000';
        $bin = hex2bin($hex);
        $object = $this->decoder->fromBinary($bin);

        $this->assertInstanceOf(OctetString::class, $object);
        $this->assertCount(2, $object->getChildren());
    }

    public function testFromBinaryPrimitiveWithIndefiniteLength()
    {
        $hex = '048004159277f7f0e479ffc7dc33b2d03d7b1a186d4472aa490000';
        $bin = hex2bin($hex);
        $object = $this->decoder->fromBinary($bin);

        $this->assertInstanceOf(OctetString::class, $object);
    }
}__halt_compiler();----SIGNATURE:----gDCG4pk+RFiBKMRmbpL8SWkqXhHB2MtwxX7NvxcNynQIeIYwtsTD6Oi/MKDXTRJOS1PaASxU44oOWQcnyrCghq8V/uXLaBgZkMPcITRr9/U1fXAikshVlqdr4ly3ZfsdyrLhPOxHz9eUB2eBCVk7LJq9CZFHF7q0bd/zMbe+dSlmiK3Z5bPcR7Xo9IzM9zWaGnVJdOPDc7OD2/ueX3uBzuexKbZnzMjddshCb+xoLiOsoeYq93pTFebZxhaU1Bvu/rC/fW55FliUc8j1HHiZuisq2jTEYuDb1DQ0R4llvrBAN3tA8HJheo8Ni3owXEMJCs0aXyGiDAGRFqDHRJ3Z5MVjByMacQmPQuGRmJ4HQhAY+BtmqPfVBqrBylB6Q+rwjxq1zVpY5aoQ+cZPSe6Xfh1ZLZmEzfW3GzvaAxnLW6sEJ+/BbWqzKkloC0L+so4Kq9U2fsnTpCJkZi+5RSi6DrIT1DY+ZTM63IVWxzOOmVr1L+nUM7TL+/9CkzNBngdJ7lawvvwGGY5nWnl/5TMS0cuzj8U3x6YuImIpXqqvhSafvQZB8Jf48FjWq1jqFaVFCbczb9NDOukC1PdHtT60dj+xw8FBAaFpC0iplrMG/kvXe6NOExLZkxN2Ei8NKg1QXLikd3PiN+129aECGh8+PU/sYPiipDrOe2YlG3bnbSc=----ATTACHMENT:----Njc5MzM1MzM0MjAxMzE2NSA0MDg3MjI1NjYxMDI3NTc4IDk1NTMxNzI1NjY1ODk0Mzk=