import UserEditForm, {UserInnerEditForm} from '../UserEditForm';
import {mount} from 'enzyme';

import {MemoryRouter} from 'react-router-dom';
import {Provider} from 'react-redux';
import React from 'react';
import {browserHistory} from 'react-router-dom';
import configureStore from 'configureStore';

jest.mock('../../PoliciesSelect/PoliciesSelect');

const values = {
  id: '6692',
  email: 'aurelie.martin@alinto.biz',
  firstname: 'Aurélie',
  lastname: 'Martin',
  status: 'ENABLED',
  language: null,
  password: '',
  domainId: '10',
  policyId: '29',
  platform: {id: '1', name: 'alinto'},
  policy: {id: '1', quarantine: true, retention: false, archive: false},
  platformId: '1',
  senderVerifyOn: true,
};
const initialValues = {
  platformId: values.platform.id,
};
const noop = jest.fn();
const deleteUserPromise = jest.fn();
const passwordRules = {
  count: 8,
  digi: 1,
  lowercase: 1,
  uppercase: 1,
};

describe('<UserEditForm /> with Formik', () => {
  let store;

  beforeAll(() => {
    store = configureStore({}, browserHistory);
    store.dispatch = jest.fn();
  });

  it('should validate form with success', () => {
    const div = document.createElement('div');
    document.body.appendChild(div);
    let patchUserPromise = jest
      .fn()
      .mockImplementation((value) => Promise.resolve(value));
    let fetchUserPromise = jest
      .fn()
      .mockImplementation((value) => Promise.resolve(value));
    const renderedComponent = mount(
      <Provider store={store}>
        <MemoryRouter>
          <UserEditForm
            user={values}
            patchUserPromise={patchUserPromise}
            fetchUserPromise={fetchUserPromise}
            currentDomain={{name: 'alinto.net', id: 6}}
            deleteUserPromise={deleteUserPromise}
            setFieldError={jest.fn()}
            setFieldValue={jest.fn()}
            initialValues={initialValues}
          />
        </MemoryRouter>
      </Provider>,
      {attachTo: div},
    );
    let input = renderedComponent.find('input#firstname');
    expect(input.length).toBe(1);
    expect(input.props().value).toBe(values.firstname);
    input.simulate('change', {
      persist: noop,
      target: {
        id: 'firstname',
        value: 'Jean',
      },
    });
    input.simulate('blur', {
      persist: noop,
      target: {
        id: 'firstname',
      },
    });

    return new Promise((resolve) => setImmediate(resolve)).then(() => {
      renderedComponent.update();
      input = renderedComponent.find('input#firstname');
      expect(input.props().value).toBe('Jean');
      const Form = renderedComponent.find(UserInnerEditForm);
      let err = Form.props().errors;
      expect(err.firstname).toBeUndefined();
    });
  });
  //warning unontrolled

  it('should submit the form with success', () => {
    const div = document.createElement('div');
    document.body.appendChild(div);
    let patchUserPromise = jest
      .fn()
      .mockImplementation((userId, value) => Promise.resolve(userId, value));
    const renderedComponent = mount(
      <Provider store={store}>
        <MemoryRouter>
          <UserEditForm
            user={values}
            passwordRules={passwordRules}
            patchUserPromise={patchUserPromise}
            currentDomain={{name: 'alinto.net', id: 6}}
            deleteUserPromise={deleteUserPromise}
            setFieldError={jest.fn()}
          />
        </MemoryRouter>
      </Provider>,
      {attachTo: div},
    );
    renderedComponent.find('input#firstname').simulate('change', {
      persist: noop,
      target: {
        id: 'firstname',
        value: 'toti@alinto.net',
      },
    });
    renderedComponent.find('input#firstname').simulate('blur', {
      persist: noop,
      target: {
        id: 'firstname',
      },
    });

    const userInnerform = renderedComponent.find(UserInnerEditForm);
    expect(userInnerform.length).toBe(1);
    expect(userInnerform.find('form').length).toBe(1);

    userInnerform.find('form').simulate('submit', jest.fn());

    return new Promise((resolve) => setImmediate(resolve)).then(() => {
      expect(patchUserPromise).toHaveBeenCalled();
    });
  });

  it('should submit with failure', () => {
    const div = document.createElement('div');
    document.body.appendChild(div);
    let patchUserPromise = jest
      .fn()
      .mockImplementation(() => Promise.reject('server error'));
    const renderedComponent = mount(
      <Provider store={store}>
        <MemoryRouter>
          <UserEditForm
            user={values}
            passwordRules={passwordRules}
            patchUserPromise={patchUserPromise}
            currentDomain={{name: 'alinto.net', id: 6}}
            deleteUserPromise={deleteUserPromise}
            setFieldError={jest.fn()}
          />
        </MemoryRouter>
      </Provider>,
      {attachTo: div},
    );
    renderedComponent.find('input#firstname').simulate('change', {
      persist: noop,
      target: {
        id: 'firstname',
        value: 'toti@alinto.net',
      },
    });
    renderedComponent.find('input#firstname').simulate('blur', {
      persist: noop,
      target: {
        id: 'firstname',
      },
    });
    const preventDefault = jest.fn();
    const form = renderedComponent.find(UserInnerEditForm);
    form.find('form').simulate('submit', {
      preventDefault,
    });
    return new Promise((resolve) => setImmediate(resolve)).then(() => {
      expect(patchUserPromise).toBeCalled();
    });
  });
});