<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
    <event name="sales_order_place_after">
        <observer name="mironsoft_loyalty_award_points_on_order_placed"
                  instance="Mironsoft\Loyalty\Observer\AwardPointsOnOrderPlaced"/>
    </event>
    <event name="sales_order_creditmemo_save_commit_after">
        <observer name="mironsoft_loyalty_reverse_points_on_creditmemo"
                  instance="Mironsoft\Loyalty\Observer\ReversePointsOnCreditmemoSave"/>
    </event>
</config>

<?php

declare(strict_types=1);

namespace Mironsoft\Loyalty\Observer;

use Magento\Customer\Api\CustomerRepositoryInterface;
use Magento\Framework\Event\Observer as EventObserver;
use Magento\Framework\Event\ObserverInterface;
use Magento\Sales\Model\Order\Creditmemo;
use Mironsoft\Loyalty\Api\Data\PointsLedgerInterface;
use Mironsoft\Loyalty\Api\Data\PointsLedgerInterfaceFactory;
use Mironsoft\Loyalty\Api\PointsLedgerRepositoryInterface;
use Mironsoft\Loyalty\Model\Config\LoyaltyConfig;
use Mironsoft\Loyalty\Model\ResourceModel\PointsLedger\CollectionFactory;
use Psr\Log\LoggerInterface;

/**
 * Reverses previously earned loyalty points when a refund is finalized, using a
 * reconciliation (target minus already-booked) instead of a per-row flag, because
 * the ledger schema (chapter 3) has no creditmemo_id to key off of.
 */
class ReversePointsOnCreditmemoSave implements ObserverInterface
{
    /**
     * @param LoyaltyConfig $loyaltyConfig Typed configuration reader (chapter 7).
     * @param CollectionFactory $ledgerCollectionFactory Reads existing ledger entries for the reconciliation.
     * @param PointsLedgerRepositoryInterface $pointsLedgerRepository Persists the reversal entry.
     * @param PointsLedgerInterfaceFactory $pointsLedgerFactory Creates a new, unsaved ledger entry.
     * @param CustomerRepositoryInterface $customerRepository Loads and saves the customer's points balance.
     * @param LoggerInterface $logger Logs failures without letting them break the refund flow.
     */
    public function __construct(
        private readonly LoyaltyConfig $loyaltyConfig,
        private readonly CollectionFactory $ledgerCollectionFactory,
        private readonly PointsLedgerRepositoryInterface $pointsLedgerRepository,
        private readonly PointsLedgerInterfaceFactory $pointsLedgerFactory,
        private readonly CustomerRepositoryInterface $customerRepository,
        private readonly LoggerInterface $logger
    ) {
    }

    /**
     * @param EventObserver $observer Carries the saved credit memo as event data.
     * @return void
     */
    public function execute(EventObserver $observer): void
    {
        /** @var Creditmemo $creditmemo */
        $creditmemo = $observer->getEvent()->getData('creditmemo');

        try {
            $this->reversePoints($creditmemo);
        } catch (\Throwable $exception) {
            $this->logger->error(
                sprintf(
                    'Mironsoft_Loyalty: failed to reverse points for creditmemo #%s: %s',
                    (string) $creditmemo->getIncrementId(),
                    $exception->getMessage()
                ),
                ['exception' => $exception]
            );
        }
    }

    /**
     * Reconciles how many points should be reversed in total for the order's
     * cumulative refunded amount, and books only the delta not yet reversed.
     *
     * @param Creditmemo $creditmemo The just-saved credit memo.
     * @return void
     */
    private function reversePoints(Creditmemo $creditmemo): void
    {
        if ($creditmemo->getState() !== Creditmemo::STATE_REFUNDED) {
            return;
        }

        $order = $creditmemo->getOrder();
        $customerId = (int) $order->getCustomerId();
        if ($order->getCustomerIsGuest() || $customerId === 0) {
            return;
        }

        $websiteId = (int) $order->getStore()->getWebsiteId();
        $pointsPerEuro = $this->loyaltyConfig->getPointsPerEuro($websiteId);
        $orderId = (int) $order->getEntityId();

        // Simplification vs. chapter 30: refund reversal uses the flat, order-wide
        // points-per-euro rate, not the per-item product multiplier or category
        // bonus a refunded item may originally have earned extra points from.
        $pointsOwedForRefund = (int) floor((float) $order->getTotalRefunded() * $pointsPerEuro);
        $alreadyReversed = $this->sumAdjustPointsForOrder($orderId);
        $delta = $pointsOwedForRefund - $alreadyReversed;

        if ($delta <= 0) {
            return; // nothing new to reverse, e.g. a comment re-saved this creditmemo
        }

        $customer = $this->customerRepository->getById($customerId);
        $currentAttribute = $customer->getCustomAttribute('loyalty_points_balance');
        $currentBalance = $currentAttribute !== null ? (int) $currentAttribute->getValue() : 0;
        $pointsToReverse = min($delta, $currentBalance);
        if ($pointsToReverse <= 0) {
            return;
        }
        $newBalance = $currentBalance - $pointsToReverse;

        // TYPE_ADJUST is the closest fit among the four fixed types from chapter 6:
        // this is a system-triggered correction, not a customer-initiated redemption.
        $ledgerEntry = $this->pointsLedgerFactory->create();
        $ledgerEntry->setCustomerId($customerId);
        $ledgerEntry->setOrderId($orderId);
        $ledgerEntry->setType(PointsLedgerInterface::TYPE_ADJUST);
        $ledgerEntry->setPoints(-$pointsToReverse);
        $ledgerEntry->setBalanceAfter($newBalance);
        $this->pointsLedgerRepository->save($ledgerEntry);

        $customer->setCustomAttribute('loyalty_points_balance', $newBalance);
        $this->customerRepository->save($customer);
    }

    /**
     * Sums the absolute value of every negative "adjust" ledger entry already
     * booked for this order - the "already reversed" side of the reconciliation.
     *
     * @param int $orderId Order entity ID.
     * @return int
     */
    private function sumAdjustPointsForOrder(int $orderId): int
    {
        $collection = $this->ledgerCollectionFactory->create();
        $collection->addOrderFilter($orderId);
        $collection->addFieldToFilter('type', ['eq' => PointsLedgerInterface::TYPE_ADJUST]);

        return (int) abs(array_sum($collection->getColumnValues('points')));
    }
}