<?php

declare(strict_types=1);

namespace Tests\Unit\Application\UseCases\CampaignRequest\Find;

use Application\UseCases\CampaignRequest\Find\FindCampaignRequest;
use Application\UseCases\CampaignRequest\Find\Input;
use Application\UseCases\CampaignRequest\Find\Output\CampaignRequestFound;
use Application\UseCases\CampaignRequest\Find\Output\CampaignRequestNotFound;
use Application\UseCases\CampaignRequest\Find\Output\Output;
use DateTime;
use Domain\Models\Entities\Brand;
use Domain\Models\Entities\CampaignRequest;
use Domain\Models\ValueObjects\Brand\BrandCode;
use Domain\Models\ValueObjects\Brand\BrandId;
use Domain\Models\ValueObjects\Brand\BrandName;
use Domain\Models\ValueObjects\Campaign\CampaignName;
use Domain\Models\ValueObjects\CampaignRequest\Applicant;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestId;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestStatus;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestType;
use Domain\Models\ValueObjects\CampaignRequest\RejectionReason;
use Domain\Models\ValueObjects\Coupon\CouponLegalInformation;
use Domain\Models\ValueObjects\Coupon\CouponLegalInformationArray;
use Domain\Models\ValueObjects\Coupon\CouponName;
use Domain\Models\ValueObjects\Coupon\CouponPicture;
use Domain\Models\ValueObjects\Coupon\CouponProductArray;
use Domain\Models\ValueObjects\Coupon\CouponValidityInformation;
use Domain\Models\ValueObjects\Coupon\CouponValidityInformationArray;
use Domain\Models\ValueObjects\IncoCode;
use Domain\Models\ValueObjects\MoneyAmount;
use Domain\Models\ValueObjects\Period;
use Domain\Models\ValueObjects\PicturePath;
use Domain\Models\ValueObjects\PrintRules;
use Domain\Models\ValueObjects\ProcessingCode;
use Domain\Models\ValueObjects\ProcessingCodeArray;
use Domain\Models\ValueObjects\RequestedCoupon\RequestedCoupon;
use Domain\Models\ValueObjects\RequestedCoupon\RequestedCouponQuantity;
use Domain\Ports\Repositories\BrandRepository;
use Domain\Ports\Repositories\CampaignRequestRepository;
use Shared\DDD\UseCases\Input as BaseInput;
use Shared\Enums\Country;
use Shared\Enums\Currency;
use Shared\ValueObjects\Email;
use Shared\ValueObjects\Money;
use Shared\ValueObjects\Rcs;

covers(FindCampaignRequest::class, Input::class, CampaignRequestFound::class, CampaignRequestNotFound::class);

describe('find campaign request use case', function (): void {
    $requestedCoupon = new RequestedCoupon(
        couponName: new CouponName('Coupon A'),
        quantity: new RequestedCouponQuantity(100),
        diffusion: new Period(new DateTime('2026-01-01'), new DateTime('2026-02-01')),
        moneyAmount: new MoneyAmount(new Money(Currency::EUR, 300)),
        couponPicture: new CouponPicture(
            new PicturePath('files/product.jpg'),
            new PicturePath('files/thumbnail.jpg'),
            new PicturePath('files/mobileThumbnail.jpg')
        ),
        couponProcessingCodes: new ProcessingCodeArray([
            new ProcessingCode('5425003944130', Country::FRANCE),
        ]),
        couponValidityInformations: new CouponValidityInformationArray([
            new CouponValidityInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::FRANCE),
            new CouponValidityInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::BENELUX)
        ]),
        couponLegalInformations: new CouponLegalInformationArray([
            new CouponLegalInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::FRANCE),
            new CouponLegalInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::BENELUX)
        ]),
        couponProducts: new CouponProductArray([new IncoCode(35784), new IncoCode(15522)]),
        printRules: new PrintRules(maxPerCustomer: 3),
    );

    it('finds a campaign request by its id, along with its brand', function () use ($requestedCoupon): void {
        // GIVEN
        $id                   = CampaignRequestId::generate();
        $brandCode            = new BrandCode('AAA01');
        $campaignRequest      = CampaignRequest::hydrate(
            id: $id,
            brandCode: $brandCode,
            name: new CampaignName('Campaign A'),
            applicant: new Applicant('John', 'Doe', new Email('john.doe@example.com')),
            campaignType: CampaignRequestType::CLUB,
            requestedCoupon: $requestedCoupon,
            status: CampaignRequestStatus::CREATED,
        );
        $brand = Brand::hydrate(
            id: BrandId::generate(),
            code: $brandCode,
            name: new BrandName('Brand A'),
            logo: new PicturePath('brands/logo.jpg'),
            rcs: new Rcs('RCS PARIS 111 222 333'),
            contact: new Email('contact@example.com'),
        );

        $repository = \Mockery::mock(CampaignRequestRepository::class);
        $repository->shouldReceive('findById')->once()->with($id)->andReturn($campaignRequest);

        $brandRepository = \Mockery::mock(BrandRepository::class);
        $brandRepository->shouldReceive('findByCode')->once()->with($brandCode)->andReturn($brand);

        $useCase = new FindCampaignRequest($repository, $brandRepository);

        // WHEN
        $result = $useCase->execute(new Input(id: $id));

        // THEN
        expect($result)->toBeInstanceOf(CampaignRequestFound::class)
            ->and($result->brand)->toBe($brand)
            ->and($result->name)->toBe($campaignRequest->name)
            ->and($result->applicant)->toBe($campaignRequest->applicant)
            ->and($result->campaignType)->toBe($campaignRequest->campaignType)
            ->and($result->requestedCoupon)->toBe($campaignRequest->requestedCoupon)
            ->and($result->status)->toBe($campaignRequest->status)
            ->and($result->rejectionReason)->toBeNull();
    });

    it('finds a rejected campaign request with its rejection reason', function () use ($requestedCoupon): void {
        // GIVEN
        $id              = CampaignRequestId::generate();
        $code            = new BrandCode('AAA01');
        $rejectionReason = new RejectionReason('Missing legal documents.');
        $campaignRequest = CampaignRequest::hydrate(
            id: $id,
            brandCode: $code,
            name: new CampaignName('Campaign A'),
            applicant: new Applicant('John', 'Doe', new Email('john.doe@example.com')),
            campaignType: CampaignRequestType::CLUB,
            requestedCoupon: $requestedCoupon,
            status: CampaignRequestStatus::REJECTED,
            rejectionReason: $rejectionReason,
        );

        $repository = \Mockery::mock(CampaignRequestRepository::class);
        $repository->shouldReceive('findById')->once()->with($id)->andReturn($campaignRequest);

        $brandRepository = \Mockery::mock(BrandRepository::class);
        $brandRepository->shouldReceive('findByCode')->once()->with($code)->andReturn(
            Brand::hydrate(
                id: BrandId::generate(),
                code: $code,
                name: new BrandName('Brand A'),
                logo: new PicturePath('brands/logo.jpg'),
                rcs: new Rcs('RCS PARIS 111 222 333'),
                contact: new Email('contact@example.com'),
            )
        );

        $useCase = new FindCampaignRequest($repository, $brandRepository);

        // WHEN
        $result = $useCase->execute(new Input(id: $id));

        // THEN
        expect($result)->toBeInstanceOf(CampaignRequestFound::class)
            ->and($result->status)->toBe(CampaignRequestStatus::REJECTED)
            ->and($result->rejectionReason)->toBe($rejectionReason);
    });

    it('returns CampaignRequestNotFound when the id is not found', function (): void {
        // GIVEN
        $id = CampaignRequestId::generate();

        $repository = \Mockery::mock(CampaignRequestRepository::class);
        $repository->shouldReceive('findById')->once()->with($id)->andReturn(null);

        $brandRepository = \Mockery::mock(BrandRepository::class);
        $brandRepository->shouldNotReceive('findByCode');

        $useCase = new FindCampaignRequest($repository, $brandRepository);

        // WHEN
        $result = $useCase->execute(new Input(id: $id));

        // THEN
        expect($result)->toBeInstanceOf(CampaignRequestNotFound::class);
    });

    it('throws when the campaign request references a brand that no longer exists', function () use ($requestedCoupon): void {
        // GIVEN
        $id                   = CampaignRequestId::generate();
        $brandCode            = new BrandCode('AAA01');
        $campaignRequest      = CampaignRequest::hydrate(
            id: $id,
            brandCode: $brandCode,
            name: new CampaignName('Campaign A'),
            applicant: new Applicant('John', 'Doe', new Email('john.doe@example.com')),
            campaignType: CampaignRequestType::CLUB,
            requestedCoupon: $requestedCoupon,
            status: CampaignRequestStatus::CREATED,
        );

        $repository = \Mockery::mock(CampaignRequestRepository::class);
        $repository->shouldReceive('findById')->once()->with($id)->andReturn($campaignRequest);

        $brandRepository = \Mockery::mock(BrandRepository::class);
        $brandRepository->shouldReceive('findByCode')->once()->with($brandCode)->andReturn(null);

        $useCase = new FindCampaignRequest($repository, $brandRepository);

        // WHEN
        $action = fn (): Output => $useCase->execute(new Input(id: $id));

        // THEN
        expect($action)->toThrow(\DomainException::class);
    });
});

describe('find campaign request use case assertions', function (): void {
    it('rejects an input of the wrong type', function (): void {
        // GIVEN
        $repository      = \Mockery::mock(CampaignRequestRepository::class);
        $brandRepository = \Mockery::mock(BrandRepository::class);
        $useCase         = new FindCampaignRequest($repository, $brandRepository);
        $invalidInput    = new class () implements BaseInput
        {
        };

        // WHEN
        $action = fn (): Output => $useCase->execute($invalidInput);

        // THEN
        expect($action)->toThrow(\InvalidArgumentException::class);
    });
});