<?php

declare(strict_types=1);

namespace Diffhead\PHP\DataEnrichmentKit\Tests;

use Diffhead\PHP\DataEnrichmentKit\Exception\PayloadIsNotJson;
use Diffhead\PHP\DataEnrichmentKit\Header;
use Diffhead\PHP\DataEnrichmentKit\Message;
use Diffhead\PHP\DataEnrichmentKit\Object\Item;
use Diffhead\PHP\DataEnrichmentKit\Object\ItemsBag;
use Diffhead\PHP\DataEnrichmentKit\Object\Request;
use Diffhead\PHP\DataEnrichmentKit\Object\Target;
use Diffhead\PHP\DataEnrichmentKit\Service\Parser;
use Diffhead\PHP\DataEnrichmentKit\Service\Serializer;
use Diffhead\PHP\DataEnrichmentKit\Storage\Requests;
use Nyholm\Psr7\Factory\Psr17Factory;
use Nyholm\Psr7\Stream;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\TestCase;

#[CoversClass(Message::class)]
#[CoversMethod(Message::class, 'setRequests')]
#[CoversMethod(Message::class, 'getRequests')]
class MessageTest extends TestCase
{
    public function testSetRequests(): void
    {
        $serializer = new Serializer();
        $parser = new Parser();
        $message = new Message($serializer, $parser);

        $psrFactory = new Psr17Factory();
        $psrMessage = $psrFactory->createResponse();

        $itemsBag = new ItemsBag();
        $itemsBag->push(new Item('key1', 'alias1'));

        $target = new Target('entity', 'field');

        $requests = new Requests([
            new Request($itemsBag, $target)
        ]);

        $header = Header::XEnrichmentRequest;
        $result = $message->setRequests($psrMessage, $header, $requests);

        $this->assertTrue($result->hasHeader($header->value));
        $this->assertNotEmpty($result->getHeader($header->value));
    }

    public function testGetRequests(): void
    {
        $serializer = new Serializer();
        $parser = new Parser();
        $message = new Message($serializer, $parser);

        $header = Header::XEnrichmentRequest;

        $psrFactory = new Psr17Factory();
        $psrMessage = $psrFactory->createResponse()
            ->withHeader($header->value, 'key1+alias1@entity,field');

        $requests = $message->getRequests($psrMessage, $header);

        $this->assertInstanceOf(Requests::class, $requests);
        $this->assertCount(1, $requests);
    }

    public function testGetPayload(): void
    {
        $serializer = new Serializer();
        $parser = new Parser();
        $message = new Message($serializer, $parser);

        $psrFactory = new Psr17Factory();
        $psrMessage = $psrFactory->createResponse()
            ->withBody(Stream::create('{"key":"value"}'));

        $payload = $message->getPayload($psrMessage);

        $this->assertIsArray($payload);
        $this->assertSame(['key' => 'value'], $payload);
    }

    public function testGetPayloadThrowsExceptionOnNonJson(): void
    {
        $this->expectException(\JsonException::class);

        $serializer = new Serializer();
        $parser = new Parser();
        $message = new Message($serializer, $parser);

        $psrFactory = new Psr17Factory();
        $psrMessage = $psrFactory->createResponse()
            ->withBody(Stream::create('Invalid JSON'));

        $this->expectException(PayloadIsNotJson::class);

        $message->getPayload($psrMessage);
    }

    public function testSetPayload(): void
    {
        $serializer = new Serializer();
        $parser = new Parser();
        $message = new Message($serializer, $parser);

        $psrFactory = new Psr17Factory();
        $psrMessage = $psrFactory->createResponse();

        $payload = ['key' => 'value'];
        $payloadString = json_encode($payload, JSON_THROW_ON_ERROR);

        $result = $message->setPayload($psrMessage, $payload);

        $this->assertEquals($payloadString, (string) $result->getBody());

        $payloadNew = ['newKey' => 'newValue'];
        $payloadNewString = json_encode($payloadNew, JSON_THROW_ON_ERROR);

        $resultNew = $message->setPayload($result, $payloadNew);

        $this->assertEquals($payloadNewString, (string) $resultNew->getBody());
    }
}