<?php

declare(strict_types=1);

namespace Tests\Unit\FormBuilder\Purposes\Resolvers;

use App\Exceptions\FormBuilder\PurposeSubjectResolutionException;
use App\FormBuilder\Purposes\Resolvers\ArtistAdvanceSubjectResolver;
use App\FormBuilder\Purposes\Resolvers\IncidentReportSubjectResolver;
use App\FormBuilder\Purposes\Resolvers\PostEventEvaluationSubjectResolver;
use App\FormBuilder\Purposes\Resolvers\SignatureContractSubjectResolver;
use App\FormBuilder\Purposes\Resolvers\SupplierIntakeSubjectResolver;
use App\FormBuilder\Purposes\Resolvers\UserProfileSubjectResolver;
use App\Models\Company;
use App\Models\CrowdType;
use App\Models\Event;
use App\Models\FormBuilder\FormSchema;
use App\Models\FormBuilder\FormSubmission;
use App\Models\Organisation;
use App\Models\Person;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

final class PurposeSubjectResolversTest extends TestCase
{
    use RefreshDatabase;

    public function test_artist_advance_throws_without_subject(): void
    {
        $submission = FormSubmission::factory()->create();

        try {
            $this->app->make(ArtistAdvanceSubjectResolver::class)->resolveOrProvision($submission);
            $this->fail('Expected PurposeSubjectResolutionException');
        } catch (PurposeSubjectResolutionException $e) {
            $this->assertSame('artist_advance', $e->purposeSlug);
            $this->assertSame('no_portal_token', $e->reasonCode);
        }
    }

    public function test_supplier_intake_returns_company_subject(): void
    {
        $organisation = Organisation::factory()->create();
        $company = Company::factory()->create(['organisation_id' => $organisation->id]);
        $submission = FormSubmission::factory()->forOrganisation($organisation)->create([
            'subject_type' => 'company',
            'subject_id' => $company->id,
        ]);

        $resolved = $this->app->make(SupplierIntakeSubjectResolver::class)
            ->resolveOrProvision($submission->fresh());

        $this->assertInstanceOf(Company::class, $resolved);
        $this->assertSame($company->id, $resolved->id);
    }

    public function test_supplier_intake_throws_without_company(): void
    {
        $submission = FormSubmission::factory()->create();

        try {
            $this->app->make(SupplierIntakeSubjectResolver::class)->resolveOrProvision($submission);
            $this->fail('Expected PurposeSubjectResolutionException');
        } catch (PurposeSubjectResolutionException $e) {
            $this->assertSame('no_production_request', $e->reasonCode);
        }
    }

    public function test_post_event_evaluation_resolves_person_via_user(): void
    {
        $event = Event::factory()->create();
        $crowdType = CrowdType::factory()->create(['organisation_id' => $event->organisation_id]);
        $user = User::factory()->create();
        $person = Person::factory()->create([
            'event_id' => $event->id,
            'crowd_type_id' => $crowdType->id,
            'user_id' => $user->id,
        ]);

        $submission = FormSubmission::factory()->forEvent($event)->create([
            'submitted_by_user_id' => $user->id,
        ]);

        $resolved = $this->app->make(PostEventEvaluationSubjectResolver::class)
            ->resolveOrProvision($submission->fresh());

        $this->assertInstanceOf(Person::class, $resolved);
        $this->assertSame($person->id, $resolved->id);
    }

    public function test_post_event_evaluation_throws_when_no_auth(): void
    {
        $submission = FormSubmission::factory()->create(['submitted_by_user_id' => null]);

        try {
            $this->app->make(PostEventEvaluationSubjectResolver::class)->resolveOrProvision($submission);
            $this->fail('Expected PurposeSubjectResolutionException');
        } catch (PurposeSubjectResolutionException $e) {
            $this->assertSame('no_auth', $e->reasonCode);
        }
    }

    public function test_incident_report_returns_null_when_anonymous(): void
    {
        $submission = FormSubmission::factory()->create(['submitted_by_user_id' => null]);

        $resolved = $this->app->make(IncidentReportSubjectResolver::class)
            ->resolveOrProvision($submission);

        $this->assertNull($resolved);
    }

    public function test_signature_contract_returns_user_subject(): void
    {
        $user = User::factory()->create();
        $submission = FormSubmission::factory()->create([
            'submitted_by_user_id' => $user->id,
        ]);

        $resolved = $this->app->make(SignatureContractSubjectResolver::class)
            ->resolveOrProvision($submission);

        $this->assertInstanceOf(User::class, $resolved);
        $this->assertSame($user->id, $resolved->id);
    }

    public function test_signature_contract_throws_without_auth(): void
    {
        $submission = FormSubmission::factory()->create(['submitted_by_user_id' => null]);

        try {
            $this->app->make(SignatureContractSubjectResolver::class)->resolveOrProvision($submission);
            $this->fail('Expected PurposeSubjectResolutionException');
        } catch (PurposeSubjectResolutionException $e) {
            $this->assertSame('no_auth', $e->reasonCode);
        }
    }

    public function test_user_profile_returns_user_subject(): void
    {
        $user = User::factory()->create();
        $submission = FormSubmission::factory()->create([
            'submitted_by_user_id' => $user->id,
        ]);

        $resolved = $this->app->make(UserProfileSubjectResolver::class)
            ->resolveOrProvision($submission);

        $this->assertInstanceOf(User::class, $resolved);
        $this->assertSame($user->id, $resolved->id);
    }
}