<?php

use Illuminate\Http\Exceptions\HttpResponseException;
use Kris\LaravelFormBuilder\Events\AfterFormValidation;
use Kris\LaravelFormBuilder\Events\BeforeFormValidation;
use Kris\LaravelFormBuilder\Fields\InputType;
use Kris\LaravelFormBuilder\Form;
use Kris\LaravelFormBuilder\FormHelper;
use Kris\LaravelFormBuilder\FormBuilder;

class FormTest extends FormBuilderTestCase
{

    /** @test */
    public function it_adds_fields()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea')
            ->add('address', 'static')
            ->add('remember', 'checkbox');

        $this->assertEquals(4, count($this->plainForm->getFields()));

        $this->assertTrue($this->plainForm->has('name'));
        $this->assertFalse($this->plainForm->has('body'));

        // Accessed with magic methods
        $this->assertEquals($this->plainForm->name, $this->plainForm->getField('name'));

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\InputType',
            $this->plainForm->getField('name')
        );

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\TextareaType',
            $this->plainForm->getField('description')
        );

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\CheckableType',
            $this->plainForm->getField('remember')
        );

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\StaticType',
            $this->plainForm->getField('address')
        );
    }

    /** @test */
    public function it_passes_validation()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['name'] = 'some name';
        $this->request['description'] = 'somedesc';

        $isValid = $this->plainForm->isValid();

        $this->assertTrue($isValid);

        $this->assertEquals(
            ['name' => ['required', 'min:5'], 'description' => ['max:10']],
            $this->plainForm->getRules()
        );
    }

    /** @test */
    public function it_fails_validation()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['description'] = 'some long description';
        $isValid = $this->plainForm->isValid();

        $this->assertFalse($isValid);

        $errors = [
            'name' => ['The Name field is required.'],
            'description' => ['The Description must not be greater than 10 characters.']
        ];

        $this->assertEquals($errors, $this->plainForm->getErrors());
    }

    /** @test */
    public function it_alters_validity_and_adds_messages()
    {
        $customForm = $this->formBuilder->create('CustomNesterDummyForm');

        $this->request['subcustom'] = ['title' => "don't fail on this"];

        $isValid = $customForm->isValid();
        $this->assertTrue($isValid);

        $this->request['subcustom'] = ['title' => 'fail on this'];

        $isValid = $customForm->isValid();
        $this->assertFalse($isValid);

        $errors = $customForm->getErrors();
        $this->assertEquals(
            ['subcustom.title' => ['Error on title!']],
            $errors
        );
    }

    /** @test */
    public function it_can_automatically_redirect_back_when_failing_verification()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['description'] = 'some long description';

        try {
            $this->plainForm->redirectIfNotValid();
            $this->fail('Expected an HttpResponseException, but was allowed to continue');
        } catch (HttpResponseException $e) {
            $response = $e->getResponse();
            $this->assertNotNull($response);

            // It should be a redirect
            $this->assertEquals(302, $response->status());

            // It should go "back" to the root, which is the fallback when no referer is given
            $this->assertEquals('http://localhost', $response->getTargetUrl());

            // It should contain the old input
            $this->assertEquals('some long description', $response->getSession()->getOldInput('description'));

            // It should contain an error
            $this->assertNotEmpty($response->getSession()->get('errors'));
            $errorBag = $response->getSession()->get('errors');
            $this->assertTrue($errorBag->has('description'));
            $this->assertTrue($errorBag->has('name'));
            $this->assertEquals('The Description must not be greater than 10 characters.', $errorBag->first('description'));
        }
    }

    /** @test */
    public function it_can_automatically_redirect_to_a_specified_destination_when_failing_verification()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['description'] = 'some long description';

        try {
            $this->plainForm->redirectIfNotValid('my-custom-destination');
            $this->fail('Expected an HttpResponseException, but was allowed to continue');
        } catch (HttpResponseException $e) {
            $response = $e->getResponse();
            $this->assertNotNull($response);

            // It should be a redirect
            $this->assertEquals(302, $response->status());

            // It should go to 'my-custom-destination'
            $this->assertEquals('http://localhost/my-custom-destination', $response->getTargetUrl());

            // It should contain the old input
            $this->assertEquals('some long description', $response->getSession()->getOldInput('description'));

            // It should contain an error
            $this->assertNotEmpty($response->getSession()->get('errors'));
            $errorBag = $response->getSession()->get('errors');
            $this->assertTrue($errorBag->has('description'));
            $this->assertTrue($errorBag->has('name'));
            $this->assertEquals('The Description must not be greater than 10 characters.', $errorBag->first('description'));
        }
    }

    /** @test */
    public function it_overrides_default_rules_and_messages()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('age', 'text', [
                'rules' => 'required',
                'error_messages' => [
                    'age.required' => 'The age field is a must.'
                ]
            ])
            ->add('email', 'email', [
                'rules' => 'required|email',
                'error_messages' => [
                    'email.email' => 'The email is needed and this will not be shown.'
                ]
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['name'] = 'name';
        $this->request['description'] = 'some long description';
        $this->request['email'] = 'invalidemail';

        $validate = $this->plainForm->validate(['name' => 'numeric'], [
            'name.numeric' => 'Name field must be numeric.',
            'email.email' => 'The email is very required.'
        ]);

        $isValid = $this->plainForm->isValid();

        $this->assertFalse($isValid);

        $errors = [
            'name' => ['Name field must be numeric.'],
            'description' => ['The Description must not be greater than 10 characters.'],
            'age' => ['The age field is a must.'],
            'email' => ['The email is very required.']
        ];

        $this->assertEquals($errors, $this->plainForm->getErrors());
    }

    /** @test */
    public function it_uses_error_messages_from_fields()
    {
        $childForm = $this->formBuilder->plain();
        $childForm->add('street', 'text', [
            'rules' => 'required|min:5',
            'error_messages' => [
                'street.min' => 'Street needs to have 5 letters.'
            ]
        ]);

        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5',
                'error_messages' => [
                    'name.required' => 'Please provide your name.'
                ]
            ])
            ->add('address', 'form', [
                'class' => $childForm
            ]);

        $this->request['address'] = ['street' => 'ab'];

        $this->assertFalse($this->plainForm->isValid());

        $errors = [
            'name' => ['Please provide your name.'],
            'address.street' => ['Street needs to have 5 letters.']
        ];

        $this->assertEquals($errors, $this->plainForm->getErrors());
    }

    /**
     * @test
     * */
    public function it_throws_exception_when_errors_requested_from_non_validated_form()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm
            ->add('name', 'text', [
                'rules' => 'required|min:5'
            ])
            ->add('description', 'textarea', [
                'rules' => 'max:10'
            ]);

        $this->request['description'] = 'some long description';
        $this->plainForm->getErrors();
    }

    /** @test */
    public function it_returns_field_values()
    {
        $this->plainForm
            ->add('name', 'text', [
                'rules' => ['required', 'min:20', 'max:255'],
            ])
            ->add('description[text]', 'textarea')
            ->add('address', 'form', [
                'class' => $this->formBuilder->plain()
                    ->add('street[name]', 'text', ['rules' => 'required']),
            ])
            ->add('user[address]', 'form', [
                'class' => $this->formBuilder->plain()
                    ->add('street', 'text', ['rules' => 'required'])
                    ->add('number', 'number'),
            ]);

        // Should return all fields, including nested, no matter validation rules
        $this->assertEquals(
            ['name', 'description.text', 'address.street.name', 'user.address.street', 'user.address.number'],
            $this->plainForm->getAllAttributes()
        );

        $this->request['status'] = 1;
        $this->request['role'] = 'admin';
        $this->request['name'] = 'Foo';
        $this->request['description'] = ['text' => 'Foo Bar'];
        $this->request['address'] = ['street' => ['id' => 1000, 'name' => 'Street 1']];
        $this->request['user'] = ['id' => 1000, 'address' => ['street' => 'Street 2']]; // Missing optional 'number'

        $check_values = [
            'name' => 'Foo',
            'description' => ['text' => 'Foo Bar'],
            'address' => ['street' => ['name' => 'Street 1']],
            'user' => ['address' => ['street' => 'Street 2']],
        ];

        // Ignore unknown data, skip missing input
        $this->assertEquals(
            $check_values,
            $this->plainForm->getFieldValues(false)
        );

        // Ignore unknown data, add NIL for missing input
        $check_values['user']['address']['number'] = null;
        $this->assertEquals(
            $check_values,
            $this->plainForm->getFieldValues()
        );
    }

    /** @test */
    public function it_returns_altered_field_values()
    {
        $customForm = $this->formBuilder->create('CustomNesterDummyForm');

        $this->request['name'] = 'lower case';
        $this->request['subcustom'] = ['title' => 'Bar foo', 'body' => 'Foo bar'];

        $this->assertEquals(
            [
                'name' => 'LOWER CASE',
                'options' => ['x'],
                'subcustom' => ['title' => 'Bar foo', 'body' => 'Foo bar'],
            ],
            $customForm->getFieldValues()
        );
    }

    /** @test */
    public function it_adds_after_some_field()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea');

        $descIndexBefore = array_search(
            'description',
            array_keys($this->plainForm->getFields())
        );

        $this->assertEquals(1, $descIndexBefore);
        $this->assertNull($this->plainForm->address);

        $this->plainForm->addAfter('name', 'address');

        $descIndexAfter = array_search(
            'description',
            array_keys($this->plainForm->getFields())
        );

        $addressIndex = array_search(
            'address',
            array_keys($this->plainForm->getFields())
        );

        $this->assertEquals(2, $descIndexAfter);
        $this->assertEquals(1, $addressIndex);

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\InputType',
            $this->plainForm->address
        );
    }

    /** @test */
    public function it_adds_before_some_field()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea');

        $descIndexBefore = array_search(
            'description',
            array_keys($this->plainForm->getFields())
        );

        $this->assertEquals(1, $descIndexBefore);
        $this->assertNull($this->plainForm->address);

        $this->plainForm->addBefore('name', 'address');

        $descIndexAfter = array_search(
            'description',
            array_keys($this->plainForm->getFields())
        );

        $addressIndex = array_search(
            'address',
            array_keys($this->plainForm->getFields())
        );

        $this->assertEquals(2, $descIndexAfter);
        $this->assertEquals(0, $addressIndex);

        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Fields\InputType',
            $this->plainForm->address
        );
    }


    /** @test */
    public function it_can_remove_existing_fields_from_form_object()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea')
            ->add('remember', 'checkbox');

        $this->assertEquals(3, count($this->plainForm->getFields()));

        $this->assertTrue($this->plainForm->has('name'));

        $this->plainForm->remove('name', 'description');

        $this->assertEquals(1, count($this->plainForm->getFields()));

        $this->assertFalse($this->plainForm->has('name'));
        $this->assertFalse($this->plainForm->has('description'));
    }

    /** @test */
    public function it_can_take_and_replace_existing_fields()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea')
            ->add('remember', 'checkbox');

        $this->plainForm->only('remember', 'name');

        $this->assertEquals(2, count($this->plainForm->getFields()));

        $this->assertTrue($this->plainForm->has('remember'));
        $this->assertTrue($this->plainForm->has('name'));
        $this->assertFalse($this->plainForm->has('description'));
    }


    /** @test */
    public function it_can_modify_existing_fields()
    {
        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea', [
                'attr' => ['placeholder' => 'Enter text here...']
            ])
            ->add('category', 'select', [
                'choices' => [ 1 => 'category-1', 2 => 'category-2']
            ]);
        // Adds new if provided name doesn't exist
        $this->plainForm->modify('remember', 'checkbox');

        $this->assertEquals('textarea', $this->plainForm->description->getType());
        $this->assertEquals(
            ['placeholder' => 'Enter text here...', 'class' => 'form-control'],
            $this->plainForm->description->getOption('attr')
        );

        $this->plainForm->modify('description', 'text', [
            'attr' => ['class' => 'modified-input']
        ]);

        $this->assertEquals('text', $this->plainForm->description->getType());
        $this->assertEquals(
            ['placeholder' => 'Enter text here...', 'class' => 'modified-input'],
            $this->plainForm->description->getOption('attr')
        );

        // Check if complete option ovewrite work
        $this->assertEquals(
            [ 1 => 'category-1', 2 => 'category-2'],
            $this->plainForm->category->getOption('choices')
        );

        $this->assertArrayNotHasKey('expanded', $this->plainForm->category->getOptions());

        $this->plainForm->modify('category', 'choice', [
            'expanded' => true
        ], true);

        $this->assertNotEquals(
            [ 1 => 'category-1', 2 => 'category-2'],
            $this->plainForm->category->getOption('choices')
        );

        $this->assertTrue($this->plainForm->category->getOption('expanded'));

    }

    /**
     * @test
     */
     public function it_throws_exception_when_rendering_until_nonexisting_field()
     {
         $this->expectException(\InvalidArgumentException::class);

         $this->plainForm
            ->add('gender', 'select')
            ->add('name', 'text');

        $this->plainForm->gender->render();
        $this->plainForm->renderUntil('nonexisting');
     }

    /**
     * @test
     */
    public function it_prevents_adding_fields_with_same_name()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm->add('name', 'text')->add('name', 'textarea');
    }

    /**
     * @test
     */
    public function it_throws_exception_if_field_name_is_reserved()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm->add('save', 'submit');
    }

    /** @test */
    public function it_throws_InvalidArgumentException_on_non_existing_property()
    {
        $exceptionThrown = false;

        $this->plainForm
            ->add('name', 'text')
            ->add('description', 'textarea');

        try {
            $this->plainForm->nonexisting;
        } catch (\InvalidArgumentException $e) {
            $exceptionThrown = true;
        }

        try {
            $this->plainForm->getField('nonexisting');
        } catch (\InvalidArgumentException $e) {
            $exceptionThrown = true;
        }

        if ($exceptionThrown) {
            $this->assertTrue($exceptionThrown);
            return;
        }

        $this->fail('Exception was not thrown for non existing field.');
    }

    /** @test */
    public function it_can_set_form_options_with_array_of_options()
    {
        $options = [
            'method' => 'POST',
            'url' => '/url/1',
            'attr' => ['class' => 'form-container'],
            'model' => $this->model
        ];

        $this->plainForm->setFormOptions($options);

        // After the setup model is removed from options
        unset($options['model']);

        $this->assertEquals($options, $this->plainForm->getFormOptions());

        $this->assertEquals('POST', $this->plainForm->getMethod());
        $this->assertEquals('/url/1', $this->plainForm->getUrl());
        $this->assertInstanceOf(
            'Illuminate\Database\Eloquent\Model',
            $this->plainForm->getModel()
        );
    }

    /** @test */
    public function it_can_set_form_options_with_setters()
    {
        $this->plainForm->setMethod('DELETE');
        $this->plainForm->setUrl('/posts/all');
        $this->plainForm->setModel($this->model);
        $this->plainForm->setName('test_name');

        $this->assertEquals(
            ['method' => 'DELETE', 'url' => '/posts/all', 'attr' => []],
            $this->plainForm->getFormOptions()
        );

        $this->assertEquals(
            $this->model,
            $this->plainForm->getModel()
        );

        $this->assertEquals('test_name', $this->plainForm->getName());
    }

    /** @test */
    public function it_sets_file_option_to_true_if_file_type_added()
    {
        $this->plainForm->add('upload_file', 'file');

        $this->assertTrue($this->plainForm->getFormOption('files'));
    }

    /** @test */
    public function it_renders_the_form()
    {
        $formOptions = [
            'method' => 'POST',
            'url' => '/someurl',
            'class' => 'has-error',
            'array_option' => ['foo' => 'bar'],
        ];

        $this->plainForm->renderForm($formOptions, true, true, true);

        $this->assertNotThrown();
    }

    /** @test */
    public function it_renders_rest_of_the_form()
    {
        $options = [
            'method' => 'GET',
            'url' => '/some/url/10'
        ];

        $fields = [
            new InputType('name', 'text', $this->plainForm),
            new InputType('email', 'email', $this->plainForm),
        ];

        $this->plainForm->setFormOptions($options);

        $this->plainForm
            ->add('gender', 'select')
            ->add('name', 'text')
            ->add('email', 'email');

        $this->plainForm->gender->render();

        $this->plainForm->renderRest();

        $this->assertNotThrown();
    }

    /** @test */
    public function it_renders_rest_of_the_form_until_specified_field()
    {
        $options = [
            'method' => 'GET',
            'url' => '/some/url/10'
        ];

        $fields = [
            new InputType('name', 'text', $this->plainForm),
            new InputType('email', 'email', $this->plainForm),
        ];

        $this->plainForm->setFormOptions($options);

        $this->plainForm
            ->add('gender', 'select')
            ->add('name', 'text')
            ->add('email', 'email')
            ->add('address', 'text');

        $this->plainForm->gender->render();

        $this->plainForm->renderUntil('email');
        $this->assertEquals($this->plainForm->address->isRendered(), false);
    }

    /** @test */
    public function it_can_add_child_form_as_field()
    {
        $model = ['song' => ['body' => 'test body'], 'title' => 'main title'];
        $form = $this->formBuilder->plain([
            'model' => $model,
        ]);
        $customForm = $this->formBuilder->create('CustomDummyForm');
        $customForm->add('img', 'file')->add('name', 'text', ['label_show' => false]);

        $form
            ->add('title', 'text', [
                'label_attr' => [
                    'for' => 'custom_title'
                ],
                'attr' => [
                    'id' => 'custom_title'
                ]
            ])
            ->add('song', 'form', [
                'class' => $customForm
            ])
            ->add('songs', 'collection', [
                'type' => 'form',
                'data' => [
                    ['title' => 'lorem', 'body' => 'ipsum'],
                    new \Illuminate\Support\Collection(['title' => 'dolor', 'body' => 'sit'])
                ],
                'options' => [
                    'class' => $customForm
                ]
            ])
        ;

        $this->assertEquals($form, $form->title->getParent());

        $view = $form->renderForm();

        $this->assertEquals('songs[1]', $customForm->getName());

        $this->assertEquals('song[title]', $form->song->getChild('title')->getName());
        $this->assertEquals('custom_title', $form->title->getOption('attr.id'));
        $this->assertEquals('custom_title', $form->title->getOption('label_attr.for'));
        $this->assertFalse($form->song->name->getOption('label_show'));
        $this->assertCount(2, $form->songs->getChildren());
        $this->assertEquals('lorem', $form->songs->getChild(0)->title->getOption('value'));
        $this->assertEquals('test body', $form->song->body->getOption('value'));
        $this->assertEquals('main title', $form->title->getOption('value'));
        $this->assertInstanceOf(
            'Kris\LaravelFormBuilder\Form',
            $form->song->getForm()
        );

        $this->assertDoesNotMatchRegularExpression('/label.*for="name"/', $view);
        $this->assertMatchesRegularExpression('/label.*for="custom_title"/', $view);
        $this->assertMatchesRegularExpression('/input.*id="custom_title"/', $view);

        $this->assertTrue($form->song->getFormOption('files'));

        try {
            $form->song->badMethod();
        } catch (\BadMethodCallException $e) {
            return;
        }
        $this->fail('No exception on bad method call on child form.');
    }

    /** @test */
    public function it_can_use_model_property_to_set_value()
    {
        $form = $this->formBuilder->plain([
            'model' => $this->model,
        ]);

        $form->add('alias_accessor', 'choice', [
            'value_property' => 'accessor',
        ]);

        $this->assertEquals($form->alias_accessor->getValue(), $this->model->accessor);
    }

    /** @test */
    public function it_sets_entity_field_value_to_the_entity_model_value()
    {
        $dummyModel = new DummyModel();
        $dummyModel->id = 1;

        $this->model->dummy_model_id = $dummyModel->id;

        $form = $this->formBuilder
            ->plain([
                'model' => $this->model,
            ])
            ->add('dummy_model_id', 'entity', [
                'class' => DummyModel::class,
                'property' => 'name',
            ]);

        $this->assertEquals($form->dummy_model_id->getValue(), $this->model->dummy_model_id);
    }

    /** @test */
    public function it_reads_configuration_properly()
    {
        $config = $this->config;
        $config['defaults']['textarea'] = ['field_class' => 'my-textarea-class'];
        $formHelper = new FormHelper($this->view, $this->translator, $config);
        $formBuilder = new FormBuilder($this->app, $formHelper, $this->eventDispatcher);

        $form = $formBuilder->plain()
            ->add('name', 'text')
            ->add('desc', 'textarea');

        $overridenClassForm = $formBuilder->plain()
            ->add('name', 'text', ['attr' => ['class' => 'my-text-class']])
            ->add('desc', 'textarea', ['attr' => ['class' => 'overwrite-textarea-class']]);

        $formView = $form->renderForm();
        $overridenView = $overridenClassForm->renderForm();

        $this->assertMatchesRegularExpression('/textarea.*class="my-textarea-class"/', $formView);
        $this->assertMatchesRegularExpression('/input.*class="form-control"/', $formView);

        $this->assertMatchesRegularExpression('/textarea.*class="overwrite-textarea-class"/', $overridenView);
        $this->assertMatchesRegularExpression('/input.*class="my-text-class"/', $overridenView);
    }

    /** @test */
    public function it_works_when_setModel_method_is_called()
    {
        $customForm = $this->formBuilder->create('CustomDummyForm')->setModel([
            'title' => 'john doe'
        ]);

        $customForm->renderForm();

        $this->assertEquals('john doe', $customForm->title->getValue());
    }

    /** @test */
    public function it_removes_children_from_parent_type_fields()
    {
        $model = ['song' => ['title' => 'test song title', 'body' => 'test body'], 'title' => 'main title'];
        $form = $this->formBuilder->plain([
            'model' => $model,
        ]);
        $customForm = $this->formBuilder->create('CustomDummyForm');

        $form
            ->add('title', 'text')
            ->add('song', 'form', [
                'class' => $customForm
            ])
            ->add('songs', 'collection', [
                'type' => 'form',
                'data' => [
                    ['title' => 'lorem', 'body' => 'ipsum'],
                    new \Illuminate\Support\Collection(['title' => 'dolor', 'body' => 'sit'])
                ],
                'options' => [
                    'class' => $customForm
                ]
            ])
        ;

        $this->assertCount(2, $form->song->getChildren());
        $this->assertCount(2, $form->song->getForm()->getFields());
        $form->song->removeChild('title');
        $this->assertCount(1, $form->song->getChildren());
        $this->assertCount(1, $form->song->getForm()->getFields());
        $this->assertEquals('test body', $form->song->body->getValue());
    }

    /** @test */
    public function it_creates_named_form()
    {
        $model = new \Illuminate\Support\Collection([
            'name' => 'John Doe',
            'gender' => 'f'
        ]);

        $expectModel = [
            'test_name' => $model->all()
        ];
        $this->plainForm
            ->add('name', 'text')
            ->add('address', 'static');
        $this->assertEquals('name', $this->plainForm->getField('name')->getName());
        $this->assertEquals('address', $this->plainForm->getField('address')->getName());
        $this->plainForm->setName('test_name')->setModel($model);
        $this->plainForm->renderForm();

        $this->assertEquals('test_name[name]', $this->plainForm->getField('name')->getName());
        $this->assertEquals('test_name[address]', $this->plainForm->getField('address')->getName());
        $this->assertEquals($expectModel, $this->plainForm->getModel());
    }

    /** @test */
    public function it_has_html_valid_element_names()
    {
        $this->plainForm
            ->add('name[text]', 'text')
            ->add('child[form]', 'form', [
                'class' => $this->formBuilder->plain()->add('name[text]', 'text'),
            ]);

        $this->assertEquals('name[text]', $this->plainForm->getField('name[text]')->getName());
        $this->assertEquals('child[form][name][text]', $this->plainForm->getField('child[form]')->getField('name[text]')->getName());
    }

    /** @test */
    public function it_adds_custom_type()
    {
        $this->plainForm->addCustomField('datetime', 'Some\\Namespace\\DatetimeType');

        $fieldType = $this->formHelper->getFieldType('datetime');

        $this->assertEquals('Some\\Namespace\\DatetimeType', $fieldType);
    }

    /**
     * @test
     */
    public function it_throws_exception_when_adding_field_with_invalid_name()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm->add('', 'text');
    }

    /**
     * @test
     */
    public function it_throws_exception_when_adding_field_with_invalid_type()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm->add('name', '');
    }

    /**
     * @test
     */
    public function it_prevents_adding_duplicate_custom_type()
    {
        $this->expectException(\InvalidArgumentException::class);

        $this->plainForm->addCustomField('datetime', 'Some\\Namespace\\DatetimeType');

        $this->plainForm->addCustomField('datetime', 'Some\\Namespace\\DateType');
    }


    /** @test */
    public function it_can_compose_another_forms_fields_into_itself()
    {
        $form = $this->formBuilder->plain();
        $customForm = $this->formBuilder->create('CustomDummyForm');

        $form
            ->add('name', 'text')
            ->compose($customForm)
        ;

        $this->assertEquals($form, $form->name->getParent());

        $this->assertEquals(3, count($form->getFields()));
        $this->assertEquals(true, $form->has('title'));
        $this->assertEquals('title', $form->title->getName());
        $this->assertEquals('title', $form->title->getRealName());
    }

    /** @test */
    public function it_disables_all_fields_in_form()
    {
        $form = $this->formBuilder->plain();

        $form->add('name', 'text')
            ->add('email', 'email')
            ->add('dummy', 'form', [
                'class' => 'CustomDummyForm'
            ]);

        $this->assertNull($form->name->getOption('attr.disabled'));

        $form->disableFields();

        $this->assertEquals('disabled', $form->name->getOption('attr.disabled'));
    }

    /** @test */
    public function it_enables_all_fields_in_form()
    {
        $form = $this->formBuilder->plain();

        $form
            ->add('name', 'text', [
                'attr' => ['disabled' => 'disabled']
            ])
            ->add('email', 'email')
            ->add('dummy', 'form', [
                'class' => 'CustomDummyForm'
            ]);

        $this->assertEquals('disabled', $form->name->getOption('attr.disabled'));

        $form->enableFields();

        $this->assertNull($form->name->getOption('attr.disabled'));
    }

    /** @test */
    public function it_allows_disabling_showing_form_errors()
    {
        $this->plainForm->add('child_form', 'form', ['class'=> 'CustomDummyForm']);
        $this->assertTrue($this->plainForm->haveErrorsEnabled());
        $this->assertTrue($this->plainForm->getField('child_form')->haveErrorsEnabled());
        $this->plainForm->setErrorsEnabled(false);
        $this->plainForm->rebuildForm();
        $this->assertFalse($this->plainForm->haveErrorsEnabled());
        $this->assertFalse($this->plainForm->getField('child_form')->haveErrorsEnabled());
    }

    /** @test */
    public function it_allows_disabling_client_validation()
    {
        $this->plainForm->add('child_form', 'form', ['class'=> 'CustomDummyForm']);
        $this->assertTrue($this->plainForm->clientValidationEnabled());
        $this->assertTrue($this->plainForm->getField('child_form')->clientValidationEnabled());

        $this->plainForm->setClientValidationEnabled(false);
        $this->plainForm->rebuildForm();

        $this->assertFalse($this->plainForm->clientValidationEnabled());
        $this->assertFalse($this->plainForm->getField('child_form')->clientValidationEnabled());
    }

    /** @test */
    public function it_receives_validation_events()
    {
        $events = [];

        $this->eventDispatcher->listen(BeforeFormValidation::class, function($event) use (&$events) {
            $events[] = get_class($event);
        });

        $this->eventDispatcher->listen(AfterFormValidation::class, function($event) use (&$events) {
            $events[] = get_class($event);
        });

        $this->plainForm->add('name', 'text', ['rules' => ['required', 'min:3']]);

        $this->request['name'] = 'Foo Bar';

        $this->plainForm->isValid();

        $this->assertEquals(
            [
                'Kris\LaravelFormBuilder\Events\BeforeFormValidation',
                'Kris\LaravelFormBuilder\Events\AfterFormValidation',
            ],
            $events
        );
    }

    /** @test */
    public function it_has_a_template_prefix()
    {
        $form = $this->formBuilder->plain();
        $form->setFormOptions(['template_prefix' => 'test::']);
        $form->add('name', 'text');

        $this->assertEquals('test::', $form->getTemplatePrefix());
        $this->assertNull($form->getFormOption('template_prefix'));
    }

    /** @test */
    public function it_stores_a_template_prefix()
    {
        $form = $this->formBuilder->plain();
        $form->setTemplatePrefix('test_prefix::');

        $this->assertEquals('test_prefix::', $form->getTemplatePrefix());
    }

    /** @test */
    public function it_uses_the_template_prefix()
    {
        $viewStub = $this->getMockBuilder('Illuminate\View\Factory')->setMethods(['make', 'with', 'render'])->disableOriginalConstructor()->getMock();
        $viewStub->method('make')->willReturn($viewStub);
        $viewStub->method('with')->willReturn($viewStub);

        $helper = new FormHelper($viewStub, $this->translator, $this->config);

        $form = $this->formBuilder->plain();
        $form->setFormOptions([
            'template_prefix' => 'test::',
            'template' => 'a_template'
        ]);

        // Check that the form uses the correct template
        $viewStub->expects($this->atLeastOnce())
                 ->method('make')
                 ->with($this->equalTo('test::a_template'));

        $form->setFormHelper($helper);
        $form->renderForm();
    }

    /** @test */
    public function it_locks_filtering()
    {
        $customPlainForm = $this->formBuilder->plain();
        $customPlainForm->lockFiltering();

        $this->assertTrue(
            $customPlainForm->isFilteringLocked()
        );
    }

    /** @test */
    public function it_returns_binded_field_filters()
    {
        $customPlainForm = $this->formBuilder->plain();
        $customPlainForm
            ->add('test_field', 'text', [
                'filters' => ['Trim', 'Uppercase']
            ])
            ->add('test_field2', 'text', [
                'filters' => ['Uppercase']
            ])
        ;

        $expected = [
            'test_field' => [
                'Trim'    => new \Kris\LaravelFormBuilder\Filters\Collection\Trim(),
                'Uppercase' => new \Kris\LaravelFormBuilder\Filters\Collection\Uppercase()
            ],
            'test_field2' => [
                'Uppercase' => new \Kris\LaravelFormBuilder\Filters\Collection\Uppercase()
            ]
        ];

        $bindedFields = $customPlainForm->getFilters();

        $this->assertEquals(
            $expected, $bindedFields
        );
    }

    /** @test */
    public function it_filter_and_mutate_fields_request_values()
    {
        $toMutateValue = ' test ';
        $this->request['test_field'] = $toMutateValue;

        $customPlainForm = $this->formBuilder->plain();
        $customPlainForm->add('test_field', 'text', [
            'filters' => ['Trim', 'Uppercase']
        ]);
        $customPlainForm->filterFields();

        $this->assertEquals('TEST', $this->request['test_field']);
    }

}
