const {graphql} = require('graphql');

const schema = require('../../../../graph/schema');
const Context = require('../../../../graph/context');
const UsersService = require('../../../../services/users');
const SettingsService = require('../../../../services/settings');

const {expect} = require('chai');

const ignoreUserMutation = `
  mutation ignoreUser ($id: ID!) {
    ignoreUser(id:$id) {
      errors {
        translation_key
      }
    }
  }
`;

const getMyIgnoredUsersQuery = `
  query myIgnoredUsers {
    me {
      ignoredUsers {
        id
        username
      }
    }
  }
`;

describe('graph.mutations.ignoreUser', () => {
  beforeEach(async () => {
    await SettingsService.init();
  });

  it('users can ignoreUser', async () => {
    let currentUser = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
    const userToIgnore = await UsersService.createLocalUser('usernameB@example.com', 'password', 'usernameB');
    let context = new Context({user: currentUser});

    const ignoreUserResponse = await graphql(schema, ignoreUserMutation, {}, context, {id: userToIgnore.id});
    if (ignoreUserResponse.errors && ignoreUserResponse.errors.length) {
      console.error(ignoreUserResponse.errors);
    }
    expect(ignoreUserResponse.errors).to.be.empty;

    // Refresh the user from the database and create the new context for the
    // request.
    currentUser = await UsersService.findById(currentUser.id);
    context = new Context({user: currentUser});

    // now check my ignored users
    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
      console.error(myIgnoredUsersResponse.errors);
    }
    expect(myIgnoredUsersResponse.errors).to.be.empty;

    const ignoredUsers = myIgnoredUsersResponse.data.me.ignoredUsers;
    expect(ignoredUsers.length).to.equal(1);
    expect(ignoredUsers[0].id).to.equal(userToIgnore.id);
    expect(ignoredUsers[0].username).to.equal(userToIgnore.username);
  });

  it('users cannot ignore themselves', async () => {
    const user = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
    const context = new Context({user});
    const ignoreUserResponse = await graphql(schema, ignoreUserMutation, {}, context, {id: user.id});
    expect(ignoreUserResponse.errors).to.not.be.empty;

    // now check my ignored users
    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
      console.error(myIgnoredUsersResponse.errors);
    }
    expect(myIgnoredUsersResponse.errors).to.be.empty;
    const myIgnoredUsers = myIgnoredUsersResponse.data.me.ignoredUsers;
    expect(myIgnoredUsers.length).to.equal(0);
  });

});

describe('graph.mutations.stopIgnoringUser', () => {
  beforeEach(async () => {
    await SettingsService.init();
  });

  it('users can stop ignoring another user they ignore', async () => {

    // We're going to ignore 2 users,
    // then stopIgnoring 1 of them
    // then assert myIgnoredUsers only lists the one remaining
    let currentUser = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
    const usersToIgnore = await Promise.all([
      UsersService.createLocalUser('usernameB@example.com', 'password', 'usernameB'),
      UsersService.createLocalUser('usernameC@example.com', 'password', 'usernameC'),
    ]);
    let context = new Context({user: currentUser});

    // ignore two users
    const ignoreUserResponses = await Promise.all(usersToIgnore.map((u) => graphql(schema, ignoreUserMutation, {}, context, {id: u.id})));
    ignoreUserResponses.forEach((response) => {
      if (response.errors && response.errors.length) {
        console.error(response.errors);
      }
      expect(response.errors).to.be.empty;
    });

    // Refresh the user from the database and create the new context for the
    // request.
    currentUser = await UsersService.findById(currentUser.id);
    context = new Context({user: currentUser});

    const stopIgnoringUserMutation = `
      mutation stopIgnoringUser ($id: ID!) {
        stopIgnoringUser(id:$id) {
          errors {
            translation_key
          }
        }
      }
    `;

    // stop ignoring one user
    const stopIgnoringUserResponse = await graphql(schema, stopIgnoringUserMutation, {}, context, {id: usersToIgnore[0].id});
    if (stopIgnoringUserResponse.errors && stopIgnoringUserResponse.errors.length) {
      console.error(stopIgnoringUserResponse.errors);
    }
    expect(stopIgnoringUserResponse.errors).to.be.empty;

    // Refresh the user from the database and create the new context for the
    // request.
    currentUser = await UsersService.findById(currentUser.id);
    context = new Context({user: currentUser});

    // now check my ignored users
    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
      console.error(myIgnoredUsersResponse.errors);
    }
    expect(myIgnoredUsersResponse.errors).to.be.empty;
    const myIgnoredUsers = myIgnoredUsersResponse.data.me.ignoredUsers;
    expect(myIgnoredUsers.length).to.equal(1);
    expect(myIgnoredUsers[0].id).to.equal(usersToIgnore[1].id);
    expect(myIgnoredUsers[0].username).to.equal(usersToIgnore[1].username);
  });

});