<?php

namespace App\Tests\Service;

use App\Entity\Status;
use App\Entity\Inventory;
use App\Entity\OrderItem;
use App\Entity\SalesOrder;
use App\Factory\OrderFactory;
use App\Service\OrderService;
use App\Service\JournalService;
use PHPUnit\Framework\TestCase;
use App\Service\OrderItemService;
use App\Repository\OrdersRepository;
use App\Repository\StatusRepository;
use App\Repository\OrderItemRepository;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\Persistence\ObjectRepository;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Component\HttpFoundation\RequestStack;

class OrderServiceTest extends TestCase
{
    private $entityManager;
    private $orderFactory;
    private $ordersRepository;
    private $orderItemRepository;
    private $orderItemService;
    private $journalService;
    private $statusRepository;
    private $cache;
    private $requestStack;
    private OrderService $orderService;

    protected function setUp(): void
    {
        $this->entityManager = $this->createMock(EntityManagerInterface::class);
        $this->orderFactory = $this->createMock(OrderFactory::class);
        $this->ordersRepository = $this->createMock(OrdersRepository::class);
        $this->orderItemRepository = $this->createMock(OrderItemRepository::class);
        $this->orderItemService = $this->createMock(OrderItemService::class);
        $this->journalService = $this->createMock(JournalService::class);
        $this->statusRepository = $this->createMock(StatusRepository::class);
        $this->cache = $this->createMock(CacheInterface::class);
        $this->requestStack = $this->createMock(RequestStack::class);

        $this->orderService = new OrderService(
            $this->createMock(Security::class),
            $this->entityManager,
            $this->ordersRepository,
            $this->orderItemRepository,
            $this->statusRepository,
            $this->orderFactory,
            $this->orderItemService,
            $this->journalService,
            $this->cache,
            $this->requestStack
        );
    }

    public function testCreateOrUpdateOrder(): void
    {
        // Mock inventory and associated objects
        $inventory = $this->createMock(Inventory::class);
        $inventory->method('getUuid')->willReturn('123e4567-e89b-12d3-a456-426614174000');
        $inventory->method('getOpeningStock')->willReturn(10);
        $inventory->method('getOpeningStockCostPrice')->willReturn(100.0);

        $item = $this->createMock(OrderItem::class);
        $inventory->method('getItem')->willReturn($item);

        $status = $this->createMock(Status::class);
        $this->statusRepository->method('find')->willReturn($status);

        // Mock repository for SalesOrder
        $salesOrderRepository = $this->createMock(ObjectRepository::class);
        $this->entityManager->method('getRepository')->willReturnMap([
            [SalesOrder::class, $salesOrderRepository],
            [Status::class, $this->statusRepository],
        ]);

        $salesOrderRepository->method('findOneBy')->willReturn(null);

        $this->entityManager->expects($this->once())
            ->method('persist')
            ->with($this->isInstanceOf(SalesOrder::class));

        $this->entityManager->expects($this->atLeastOnce())
            ->method('flush');

        // Callables for initialization and update logic
        $orderInitializer = function (SalesOrder $order, Inventory $inventoryItem) {
            $order->setUuid($inventoryItem->getUuid());
            $order->setStatus(new Status());
        };

        $itemUpdater = function (OrderItem $orderItem, Inventory $inventoryItem) {
            $orderItem->setQty($inventoryItem->getOpeningStock());
            $orderItem->setUnitPrice($inventoryItem->getOpeningStockCostPrice());
        };

        // Execute the method
        $salesOrder = $this->orderService->createOrUpdateOrder(
            SalesOrder::class,
            $inventory,
            $orderInitializer,
            $itemUpdater
        );

        // Assertions
        $this->assertInstanceOf(SalesOrder::class, $salesOrder);
        $this->assertNotEmpty($salesOrder->getOrderLineItems());
    }

    public function testFindOrCreateOrderItem(): void
    {
        // Mock order and inventory
        $order = $this->createMock(SalesOrder::class);
        $inventory = $this->createMock(Inventory::class);
        $item = $this->createMock(OrderItem::class);
        $inventory->method('getItem')->willReturn($item);

        // Mock repository behavior
        $this->orderItemRepository->method('findOneBy')->willReturn(null);

        $orderItem = $this->orderService->findOrCreateOrderItem($order, $inventory);

        $this->assertInstanceOf(OrderItem::class, $orderItem);
    }

    public function testUpdateOrderTotals(): void
    {
        // Mock order with line items
        $order = $this->getMockBuilder(SalesOrder::class)
            ->onlyMethods(['getOrderLineItems', 'setSubtotal', 'setTotalDiscount', 'setVatAmount', 'setTotal'])
            ->getMock();

        $orderItem1 = $this->createMock(OrderItem::class);
        $orderItem1->method('getQty')->willReturn(2);
        $orderItem1->method('getUnitPrice')->willReturn(100.0);
        $orderItem1->method('getDiscountAmount')->willReturn(10.0);
        $orderItem1->method('getVatAmount')->willReturn(20.0);

        $orderItem2 = $this->createMock(OrderItem::class);
        $orderItem2->method('getQty')->willReturn(1);
        $orderItem2->method('getUnitPrice')->willReturn(200.0);
        $orderItem2->method('getDiscountAmount')->willReturn(0.0);
        $orderItem2->method('getVatAmount')->willReturn(40.0);

        $order->method('getOrderLineItems')->willReturn([$orderItem1, $orderItem2]);

        $order->expects($this->once())->method('setSubtotal')->with(400.0);
        $order->expects($this->once())->method('setTotalDiscount')->with(20.0);
        $order->expects($this->once())->method('setVatAmount')->with(80.0);
        $order->expects($this->once())->method('setTotal')->with(460.0);

        $this->orderService->updateOrderTotals($order);
    }
}