<?php

namespace App\Tests\Service;

use App\Entity\Orders;
use App\Entity\Inventory;
use App\Service\OrderService;
use App\Service\OrderType\StockOrderHandler;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\TestCase;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Psr\Log\LoggerInterface;

class OrderServiceTest extends TestCase
{
    private $entityManager;
    private $security;
    private $cache;
    private $requestStack;
    private $handlers;
    private $logger;
    private $orderService;

    protected function setUp(): void
    {
        // Mock dependencies
        $this->entityManager = $this->createMock(EntityManagerInterface::class);
        $this->security = $this->createMock(Security::class);
        $this->cache = $this->createMock(CacheInterface::class);
        $this->requestStack = $this->createMock(RequestStack::class);
        $this->logger = $this->createMock(LoggerInterface::class);

        // Mock handlers
        $stockOrderHandler = $this->createMock(StockOrderHandler::class);

        $this->handlers = [
            StockOrderHandler::class => $stockOrderHandler
        ];

        $this->orderService = new OrderService(
            $this->entityManager,
            $this->security,
            $this->cache,
            $this->requestStack,
            $this->handlers
        );
    }

    public function testCreateOrder(): void
    {
        $stockOrderHandler = $this->handlers[StockOrderHandler::class];

        $stockOrderHandler->expects($this->once())
            ->method('createOrder')
            ->willReturn(new Orders());

        $order = $this->orderService->createOrder(StockOrderHandler::class);

        $this->assertInstanceOf(Orders::class, $order);
    }

    public function testUpdateOrderDetails(): void
    {
        $order = new Orders();
        $inventory = $this->createMock(Inventory::class);

        $stockOrderHandler = $this->handlers[StockOrderHandler::class];

        $stockOrderHandler->expects($this->once())
            ->method('updateOrderDetails')
            ->with([$order], ['inventory' => [$inventory]]);

        $this->orderService->updateOrderDetails(StockOrderHandler::class, $order, ['inventory' => [$inventory]]);
    }

    public function testAddOrUpdateOrderItem(): void
    {
        $order = new Orders();
        $inventory = $this->createMock(Inventory::class);

        $stockOrderHandler = $this->handlers[StockOrderHandler::class];

        $stockOrderHandler->expects($this->once())
            ->method('updateOrderDetails')
            ->with([$order], ['inventory' => [$inventory]]);

        $this->orderService->addOrUpdateOrderItem(StockOrderHandler::class, $inventory, $order);
    }

    public function testHandlerNotFoundException(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Handler not found for class: NonExistentHandler');

        $this->orderService->createOrder('NonExistentHandler');
    }

    public function testIntegrationWithCache(): void
    {
        $this->cache->expects($this->once())
            ->method('get')
            ->with(
                'order_cache_key', // The cache key must be a string
                $this->isInstanceOf(\Closure::class) // The second argument is a callable
            )
            ->willReturn('cached_order_data');

        // Example of interacting with the cache (depends on service usage)
        $result = $this->cache->get('order_cache_key', function () {
            return 'new_order_data';
        });

        $this->assertEquals('cached_order_data', $result);
    }
}