const db = require('../database')
const Errors = require('../common/errors')
const crypto = require('../common/crypto')
const Mailers = require('../mailers')
const Mailing = require('../helpers/mailing')
const Status = require('../models/user-status')
const ActivitiesService = require('./activities-service')
const ResponseBuilder = require('./response-builders/user-response')
const UserValidator = require('../validation/model/user')

async function getUserBySlug(slug) {
  const user = await db.User.findOne({
    where: {
      slug,
      emailConfirmedAt: { $ne: null },
      status: Status.ACTIVE,
    },
    include: [
      {
        model: db.Board.scope('active'),
        as: 'boards',
        required: false,
        include: [
          {
            model: db.Item,
            as: 'items',
            through: { as: 'boardItem' },
            required: false,
            include: [
              { model: db.BoardItem, as: 'boardsItems' },
            ],
          },
        ],
      },
    ],
    order: [
      [
        { model: db.Board, as: 'boards' },
        'position',
        'ASC',
      ],
      [
        { model: db.Board, as: 'boards' },
        { model: db.Item, as: 'items' },
        { model: db.BoardItem, as: 'boardsItems' },
        'position',
        'ASC',
      ],
    ],
  })

  if (!user) {
    throw new Errors.RecordNotFoundError('User does not exist')
  }

  return user
}

async function updateBoardPosition(id, userId, position, transaction) {
  const board = await db.Board.findOne({
    where: {
      id,
      userId,
      status: Status.ACTIVE,
    },
  })

  if (!board) {
    throw new Errors.RecordNotFoundError(`Board with id ${id} does not exist`)
  }

  await board.update({ position }, { transaction })
}

module.exports = {
  async showUser(slug) {
    const user = await getUserBySlug(slug)

    return {
      user: ResponseBuilder.profile(user),
    }
  },

  async register(data) {
    await UserValidator.validateData(data)

    const user = await db.User.create(Object.assign(data, {
      status: Status.PENDING_EMAIL,
    }))
    Mailing.send(Mailers.UserMailer.confirmEmail(user))

    return ResponseBuilder.signedUser(user)
  },

  async signIn(data) {
    const user = await db.User.findOne({
      where: {
        email: data.email,
      },
    })

    if (user && await crypto.comparePasswords(data.password, user.password)) {
      return ResponseBuilder.signedUser(user)
    }

    throw new Errors.BadRequestError('User could not be signed in')
  },

  async confirmEmail(id, data) {
    const user = await db.User.findOne({
      where: {
        id,
        emailConfirmationToken: data.emailConfirmationToken,
        emailConfirmedAt: { $eq: null },
        status: Status.PENDING_EMAIL,
      },
    })

    if (user) {
      await user.update({
        emailConfirmationToken: null,
        emailConfirmedAt: new Date(),
        status: Status.PENDING_USERNAME,
      })
      return ResponseBuilder.signedUser(user)
    }

    throw new Errors.BadRequestError('Email could not be confirmed')
  },

  async resendEmailConfirmation(data) {
    const user = await db.User.findOne({
      where: {
        email: data.email,
        status: Status.PENDING_EMAIL,
      },
    })

    if (!user) {
      const msg = `User with email ${data.email} and ${Status.PENDING_EMAIL} status does not exist`
      throw new Errors.RecordNotFoundError(msg)
    }

    Mailing.send(Mailers.UserMailer.confirmEmail(user))

    return ResponseBuilder.signedUser(user)
  },

  async requestPasswordReset(data) {
    const user = await db.User.findOne({ where: { email: data.email } })

    if (!user) {
      throw new Errors.RecordNotFoundError(`User with email ${data.email} does not exist`)
    }

    const passwordResetToken = await crypto.generateCommonToken()

    await user.update({
      passwordResetToken,
    })

    Mailing.send(Mailers.UserMailer.resetPassword(user))
  },

  async setNewPassword(data) {
    const user = await db.User.findOne({
      where: {
        passwordResetToken: data.passwordResetToken,
      },
    })

    if (user) {
      const password = await crypto.hashPassword(data.password)

      await user.update({
        password,
        passwordResetToken: null,
      })

      return ResponseBuilder.signedUser(user)
    }

    throw new Errors.BadRequestError('Password could not be changed')
  },

  async setUsername(id, data) {
    const user = await db.User.findOne({
      where: {
        id,
        status: Status.PENDING_USERNAME,
      },
    })

    if (!user) {
      const msg = `User with id ${id} and status ${Status.PENDING_USERNAME} does not exist`

      throw new Errors.RecordNotFoundError(msg)
    }

    await UserValidator.validateData(data, id)

    await user.update(Object.assign(data, {
      status: Status.ACTIVE,
    }))

    ActivitiesService.create(user, user.id)

    return ResponseBuilder.signedUser(user)
  },

  async validateUser(data) {
    const errors = await UserValidator.userErrors(data)
    const valid = Object.keys(errors).length === 0

    return {
      valid,
      errors,
    }
  },

  async updateUser(data, user) {
    await user.update(data)

    return ResponseBuilder.signedUser(user)
  },

  async authFromFacebook(facebookUser) {
    const facebookIdMatchUser = await db.User.findOne({ where: { facebookId: facebookUser.id } })
    if (facebookIdMatchUser) {
      return ResponseBuilder.signedUser(facebookIdMatchUser)
    }

    const emailMatchUser = await db.User.findOne({ where: { email: facebookUser.email } })
    if (emailMatchUser) {
      const data = { facebookId: facebookUser.id }

      if (emailMatchUser.status === Status.PENDING_EMAIL) {
        data.status = Status.PENDING_USERNAME
        data.emailConfirmationToken = null
        data.emailConfirmedAt = new Date()
      }

      await emailMatchUser.update(data)

      return ResponseBuilder.signedUser(emailMatchUser)
    }

    // random password
    const password = await crypto.generateCommonToken()

    const user = await db.User.create({
      email: facebookUser.email,
      name: [facebookUser.first_name, facebookUser.last_name].join(' '),
      password,
      facebookId: facebookUser.id,
      status: Status.PENDING_USERNAME,
      emailConfirmationToken: null,
      emailConfirmedAt: new Date(),
    })

    return ResponseBuilder.signedUser(user)
  },

  async updateBoardsOrder(slug, data) {
    let user = await getUserBySlug(slug)

    if (user.boards.length !== data.boards.length) {
      throw new Errors.BadRequestError('Wrong number of Boards')
    }

    const transaction = await db.sequelize.transaction()

    try {
      await Promise.all(data.boards.map(board =>
        updateBoardPosition(board.id, user.id, board.position, transaction)
      ))

      await transaction.commit()
    } catch (err) {
      await transaction.rollback()
      throw err
    }

    // refetch user again to obtain ordered boards
    user = await getUserBySlug(slug)

    return {
      user: ResponseBuilder.profile(user),
    }
  },
}