<?php

use App\Models\Audition;
use App\Models\Ensemble;
use App\Models\Entry;
use App\Models\PrelimDefinition;
use App\Models\Room;
use App\Models\ScoringGuide;
use App\Models\Seat;
use App\Models\SeatingLimit;
use App\Models\SubscoreDefinition;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(RefreshDatabase::class);

beforeEach(function () {
    $this->audition = Audition::factory()->create(['entry_fee' => 2000]);
});

it('can return its event', function () {
    expect($this->audition->event)->toBeInstanceOf(App\Models\Event::class);
});

it('can return its entries', function () {
    Entry::factory()->count(5)->create(['audition_id' => $this->audition->id]);
    expect($this->audition->entries)->toBeInstanceOf(Illuminate\Database\Eloquent\Collection::class)
        ->and($this->audition->entries->count())->toBeGreaterThan(0)
        ->and($this->audition->entries->first())->toBeInstanceOf(App\Models\Entry::class);
});

it('can return its unscored entries', function () {
    $entries = Entry::factory()->count(25)->create(['audition_id' => $this->audition->id]);
    DB::table('entry_total_scores')->insert([
        'entry_id' => $entries[0]->id,
        'seating_total' => 10,
        'advancement_total' => 10,
        'seating_subscore_totals' => json_encode([5, 5]),
        'advancement_subscore_totals' => json_encode([5, 5]),
    ]);
    $entries[1]->addFlag('no_show');
    $entries[2]->addFlag('failed_prelim');
    expect($this->audition->unscoredEntries)->toBeInstanceOf(Illuminate\Database\Eloquent\Collection::class)
        ->and($this->audition->unscoredEntries->count())->toBe(22)
        ->and($this->audition->unscoredEntries->first())->toBeInstanceOf(App\Models\Entry::class)
        ->and($this->audition->unscoredEntries->doesntContain($entries[0]))->toBeTrue()
        ->and($this->audition->unscoredEntries->doesntContain($entries[1]))->toBeTrue()
        ->and($this->audition->unscoredEntries->doesntContain($entries[2]))->toBeTrue()
        ->and($this->audition->unscoredEntries->contains($entries[12]))->toBeTrue()
        ->and($this->audition->unscoredEntries->contains($entries[8]))->toBeTrue();
});

it('can return its room if one is set', function () {
    expect($this->audition->room)->toBeNull();
    $room = Room::factory()->create();
    $this->audition->room()->associate($room);
    $this->audition->save();
    expect($this->audition->room)->toBeInstanceOf(App\Models\Room::class);
});

it('can return its scoring guide if one is set', function () {
    expect($this->audition->scoringGuide)->toBeNull();
    $guide = App\Models\ScoringGuide::factory()->create();
    $this->audition->scoringGuide()->associate($guide);
    $this->audition->save();
    expect($this->audition->scoringGuide)->toBeInstanceOf(App\Models\ScoringGuide::class);
});

it('can return the subscore definitions for its scoring guide if one is set', function () {
    expect($this->audition->scoringGuide)->toBeNull();
    $guide = ScoringGuide::factory()->create();
    $subscores = SubscoreDefinition::orderBy('display_order')->get();
    $n = 1;
    foreach ($subscores as $subscore) {
        $subscore->update(['display_order' => $n]);
        $n++;
    }
    $subscores[0]->update(['for_seating' => 0]);
    $subscores[4]->update(['for_advance' => 0]);
    $this->audition->scoringGuide()->associate($guide);
    $this->audition->save();
    expect($this->audition->scoringGuide)->toBeInstanceOf(ScoringGuide::class)
        ->and($this->audition->getSeatingSubscores()->contains('id', $subscores[0]->id))->toBeFalse()
        ->and($this->audition->getSeatingSubscores()->contains('id', $subscores[1]->id))->toBeTrue()
        ->and($this->audition->getSeatingSubscores()->contains('id', $subscores[2]->id))->toBeTrue()
        ->and($this->audition->getSeatingSubscores()->contains('id', $subscores[3]->id))->toBeTrue()
        ->and($this->audition->getSeatingSubscores()->contains('id', $subscores[4]->id))->toBeTrue()
        ->and($this->audition->getAdvancementSubscores()->contains('id', $subscores[4]->id))->toBeFalse()
        ->and($this->audition->getAdvancementSubscores()->contains('id', $subscores[3]->id))->toBeTrue()
        ->and($this->audition->getAdvancementSubscores()->contains('id', $subscores[2]->id))->toBeTrue()
        ->and($this->audition->getAdvancementSubscores()->contains('id', $subscores[1]->id))->toBeTrue()
        ->and($this->audition->getAdvancementSubscores()->contains('id', $subscores[0]->id))->toBeTrue();

});

it('can return its bonus score definition if one is set', function () {
    expect($this->audition->bonusScore()->count())->toBe(0);
    $definition = App\Models\BonusScoreDefinition::factory()->create();
    $this->audition->bonusScore()->attach($definition);
    $this->audition->save();
    expect($this->audition->bonusScore->first())->toBeInstanceOf(App\Models\BonusScoreDefinition::class);
});

it('can return its seating limits if any are set', function () {
    $we = Ensemble::create([
        'code' => 'we',
        'name' => 'Wind Ensemble',
        'event_id' => $this->audition->event_id,
        'rank' => 1,
    ]);
    $alt = Ensemble::create([
        'code' => 'alt',
        'name' => 'Alternates',
        'event_id' => $this->audition->event_id,
        'rank' => 2,
    ]);
    expect($this->audition->seatingLimits()->count())->toBe(0);
    SeatingLimit::create(['ensemble_id' => $we->id, 'audition_id' => $this->audition->id, 'maximum_accepted' => 8]);
    SeatingLimit::create(['ensemble_id' => $alt->id, 'audition_id' => $this->audition->id, 'maximum_accepted' => 2]);
    expect($this->audition->seatingLimits()->count())->toBe(2)
        ->and($this->audition->seatingLimits->first())->toBeInstanceOf(App\Models\SeatingLimit::class)
        ->and($this->audition->seatingLimits->first()->maximum_accepted)->toBe(8)
        ->and($this->audition->seatingLimits->first()->ensemble->name)->toBe('Wind Ensemble');
});

it('returns entry fee in currency format', function () {
    expect($this->audition->display_fee())->toBe('$20.00');
});

it('can return its judges', function () {
    expect($this->audition->judges()->count())->toBe(0);
    $room = Room::factory()->create();
    $this->audition->room()->associate($room);
    $this->audition->save();
    $judge = App\Models\User::factory()->create();
    $room->judges()->attach($judge);
    expect($this->audition->judges()->count())->toBe(1)
        ->and($this->audition->judges->first())->toBeInstanceOf(App\Models\User::class);
});

it('can return a count of judges', function () {
    expect($this->audition->judges()->count())->toBe(0);
    $room = Room::factory()->create();
    $this->audition->room()->associate($room);
    $this->audition->save();
    $judge = App\Models\User::factory()->create();
    $room->judges()->attach($judge);
    expect($this->audition->judges_count)->toBe(1);
});

it('can return all of its flags', function () {
    expect($this->audition->flags()->count())->toBe(0);
    $this->audition->addFlag('seats_published');
    $this->audition->addFlag('advancement_published');
    $this->audition->refresh();
    expect($this->audition->flags()->count())->toBe(2);
});

it('can check for a specific flag', function () {
    expect($this->audition->flags()->count())->toBe(0);
    $this->audition->addFlag('seats_published');
    $this->audition->refresh();
    expect($this->audition->hasFlag('seats_published'))->toBeTrue()
        ->and($this->audition->hasFlag('advancement_published'))->toBeFalse();
});

it('can remove a flag', function () {
    expect($this->audition->flags()->count())->toBe(0);
    $this->audition->addFlag('seats_published');
    $this->audition->refresh();
    expect($this->audition->hasFlag('seats_published'))->toBeTrue();
    $this->audition->removeFlag('seats_published');
    $this->audition->refresh();
    expect($this->audition->hasFlag('seats_published'))->toBeFalse();
});

it('will not add a flag that already exists', function () {
    expect($this->audition->flags()->count())->toBe(0);
    $this->audition->addFlag('seats_published');
    $this->audition->refresh();
    expect($this->audition->hasFlag('seats_published'))->toBeTrue();
    $this->audition->addFlag('seats_published');
    expect($this->audition->flags()->count())->toBe(1);
});

it('can return its seats if any exits', function () {
    expect($this->audition->seats()->count())->toBe(0);
    $ensemble = Ensemble::factory()->create();
    $entries = Entry::factory()->count(5)->create(['audition_id' => $this->audition->id]);
    $n = 1;
    foreach ($entries as $entry) {
        Seat::create([
            'ensemble_id' => $ensemble->id,
            'audition_id' => $this->audition->id,
            'entry_id' => $entry->id,
            'seat' => $n,
        ]);
        $n++;
    }
    expect($this->audition->seats()->count())->toBe(5)
        ->and($this->audition->seats->first())->toBeInstanceOf(Seat::class);
});

it('returns null if a prelim definition is requested and none exists', function () {
    expect($this->audition->prelimDefinition)->toBeNull();
});

it('can return its prelim definition if one exists', function () {

    $prelimDefinition = PrelimDefinition::create([
        'audition_id' => $this->audition->id,
        'passing_score' => 72,
    ]);
    expect($this->audition->prelimDefinition->passing_score)->toEqual(72);
});