<?php

namespace Tests\Feature;

use App\Models\Event;
use App\Models\EventCategory;
use App\Models\Memo;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Symfony\Component\HttpFoundation\Response;
use Tests\TestCase;

class EventsTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function an_admin_can_create_an_event_category()
    {
        $this->withoutExceptionHandling();
        $this->actingAs($user = factory(User::class)->create(['role' => 2]), 'api');

        $response = $this->post('/api/events/categories', [
            'name' => 'Test name event category',
            'description' => 'Test description event category',
        ])->assertStatus(201);

        $category = EventCategory::first();

        $this->assertEquals('Test name event category', $category->name);
        $this->assertEquals('Test description event category', $category->description);
        $response->assertJson([
            'data' => [
                'type' => 'event categories',
                'event_category_id' => $category->id,
                'attributes' => [
                    'data' => [
                        'name' => $category->name,
                        'description' => $category->description,
                    ]
                ],
            ],
            'links' => [
                'self' => url('/events/categories/'.$category->id),
            ]
        ]);
    }

    /** @test */
    public function event_category_name_are_required()
    {
        $this->actingAs($user = factory(\App\Models\User::class)->create(['role' => 2]), 'api');
        $response = $this->post('/api/events/categories', ['name' => '', 'description' => 'test name required']);

        $response->assertSessionHasErrors('name');
        $this->assertCount(0, EventCategory::all());
    }

    /** @test */
    public function only_admin_can_create_event_category()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');
        $response = $this->post('/api/events/categories', ['name' => 'Test fail', 'description' => 'test name required']);

        $response->assertStatus(403);
        $this->assertCount(0, EventCategory::all());
    }

    /** @test */
    public function an_event_category_can_be_retrieved()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');

        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);

        $response = $this->get('/api/events/categories/' . $category->id );

        $response->assertJson([
            'data' => [
                'type' => 'event categories',
                'event_category_id' => $category->id,
                'attributes' => [
                    'data' => [
                        'name' => $category->name,
                        'description' => $category->description,
                    ]
                ],
            ]
        ]);
    }

    /** @test */
    public function all_event_categories_can_be_retrieved()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');

        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);
        $categoryTwo = EventCategory::create(['name' => 'Test category 2', 'description' => 'Test description']);
        $categoryTree = EventCategory::create(['name' => 'Test category 3', 'description' => 'Test description']);

        $response = $this->get('/api/events/categories');

        $response->assertJson([
            'data' => [
                [
                    'data' => [
                        'type' => 'event categories',
                        'event_category_id' => $category->id,
                        'attributes' => [
                            'data' => [
                                'name' => $category->name,
                                'description' => $category->description,
                            ]
                        ],
                    ],
                ],
                [
                    'data' => [
                        'type' => 'event categories',
                        'event_category_id' => $categoryTwo->id,
                        'attributes' => [
                            'data' => [
                                'name' => $categoryTwo->name,
                                'description' => $categoryTwo->description,
                            ]
                        ],
                    ],
                ],
                [
                    'data' => [
                        'type' => 'event categories',
                        'event_category_id' => $categoryTree->id,
                        'attributes' => [
                            'data' => [
                                'name' => $categoryTree->name,
                                'description' => $categoryTree->description,
                            ]
                        ],
                    ],
                ],
            ],

        ]);
    }

    /** @test */
    public function a_event_category_can_be_patch()
    {
        $this->actingAs($user = factory(User::class)->create(['role' => 2]), 'api');

        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);

        $response = $this->patch('/api/events/categories/' . $category->id, ['name' => 'Update Catégory']);

        $category = $category->fresh();

        $this->assertEquals('Update Catégory', $category->name);

        $response->assertStatus(200);
        $response->assertJson([
            'data' => [
                'type' => 'event categories',
                'event_category_id' => $category->id,
                'attributes' => [
                    'data' => [
                        'name' => $category->name,
                        'description' => $category->description,
                    ]
                ],
            ],
        ]);
    }

    /** @test */
    public function only_the_admin_can_patch_the_memo()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');
        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);

        $response = $this->patch('/api/events/categories/' . $category->id, ['name' => 'try to update']);

        $response->assertStatus(403);
    }

    /** @test */
    public function an_event_category_can_be_delete()
    {
        $this->actingAs($user = factory(User::class)->create(['role' => 2]), 'api');
        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);

        $response = $this->delete('/api/events/categories/' . $category->id);

        $category = $category->fresh();

        $this->assertCount(0, EventCategory::all());

        $response->assertStatus(204);
    }

    /** @test */
    public function only_admin_can_delete_an_event_category()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');
        $category = EventCategory::create(['name' => 'Test category', 'description' => 'Test description']);

        $response = $this->delete('/api/events/categories/' . $category->id);

        $response->assertStatus(403);
    }

    /** @test */
    public function a_user_can_create_an_event()
    {
        $this->withoutExceptionHandling();
        $this->actingAs($user = factory(User::class)->create(), 'api');

        app(\DatabaseSeeder::class)->call(\EventCategorySeeder::class);

        //dd(EventCategory::all());
        $response = $this->post('/api/events', $this->data())->assertStatus(201);

        $event = Event::first();

        $this->assertEquals($user->id, $event->user_id);
        $this->assertEquals(1, $event->category_id);
        $this->assertEquals('Test name event', $event->name);
        $this->assertEquals('Test description event', $event->description);
        $this->assertEquals('2020-07-20 09:00:00', $event->start_date);
        $this->assertEquals('2020-07-26 09:00:00', $event->end_date);
        $this->assertEquals('Marcillac', $event->location);
        $response->assertJson([
            'data' => [
                'type' => 'events',
                'event_id' => $event->id,
                'attributes' => [
                    'data' => [
                        'name' => $event->name,
                        'description' => $event->description,
                        'start_date' => $event->start_date,
                        'end_date' => $event->end_date,
                        'location' => $event->location,
                        'category' => [
                            'data' => [
                                'category_id' => 1
                            ],
                        ],
                    ]
                ],
            ],
            'links' => [
                'self' => url('/events/'.$event->id),
            ]
        ]);
    }

    /** @test */
    public function event_name_are_required()
    {
        $this->actingAs($user = factory(\App\Models\User::class)->create(), 'api');
        $response = $this->post('/api/events', array_merge($this->data(), ['name' => '']));

        $response->assertSessionHasErrors('name');
        $this->assertCount(0, EventCategory::all());
    }

    /** @test */
    public function event_start_date_are_required()
    {
        $this->actingAs($user = factory(\App\Models\User::class)->create(), 'api');
        $response = $this->post('/api/events', array_merge($this->data(), ['start_date' => '']));

        $response->assertSessionHasErrors('start_date');
        $this->assertCount(0, EventCategory::all());
    }

    /** @test */
    public function an_event_can_be_retrieved()
    {
        $this->actingAs($user = factory(User::class)->create(), 'api');
        app(\DatabaseSeeder::class)->call(\EventCategorySeeder::class);

        $event = $user->events()->create($this->data());

        $response = $this->get('/api/events/' . $event->id );

        $response->assertJson([
            'data' => [
                'type' => 'events',
                'event_id' => $event->id,
                'attributes' => [
                    'data' => [
                        'name' => $event->name,
                        'description' => $event->description,
                        'start_date' => $event->start_date,
                        'end_date' => $event->end_date,
                        'location' => $event->location,
                        'category' => [
                            'data' => [
                                'category_id' => 1
                            ],
                        ],
                    ]
                ],
            ],
        ]);
    }


    private function data()
    {
        return [
            'name' => 'Test name event',
            'description' => 'Test description event',
            'category_id' => 1,
            'start_date' => '2020-07-20 09:00:00',
            'end_date' => '2020-07-26 09:00:00',
            'location' => 'Marcillac',
        ];
    }
}