import moment from 'moment'
import { logger } from '../../utils/logger'
import { prismaClient as prisma } from '../../prismaClient'
import * as Notification from '../../utils/notification'

export default async function verifyEventReminder() {
  try {
    logger.info('Verify event reminder')

    if (moment().hours() >= 21 || moment().hours() <= 7) {
      logger.info("Will not process events because it's in the night")
      return Promise.resolve()
    }

    const events = await prisma.event.findMany({
      where: {
        hasAlertReminder: true,
        OR: [
          {
            firstReminderSentAt: null,
          },
          {
            secondReminderSentAt: null,
          },
        ],
      },
      select: {
        id: true,
        createdAt: true,
        title: true,
        description: true,
        start: true,
        end: true,
        firstReminderSentAt: true,
        secondReminderSentAt: true,
        segments: {
          select: {
            id: true,
            users: {
              select: {
                id: true,
              },
            },
            properties: {
              select: {
                users: {
                  select: {
                    id: true,
                  },
                },
                owners: {
                  select: {
                    id: true,
                  },
                },
              },
            },
          },
        },
        project: {
          select: {
            id: true,
            name: true,
            managingCompany: {
              select: {
                id: true,
                shortName: true,
                longName: true,
                logo: {
                  select: {
                    url: true,
                  },
                },
              },
            },
            users: {
              select: {
                id: true,
              },
            },
          },
        },
      },
    })

    logger.info(`Number of events to process ${events.length}`)

    await events.reduce(async (promiseEvent, event) => {
      await promiseEvent

      logger.info(
        `Processing event ${event.title}, ${moment(event.start).format('LLL')}, ${
          event.project.name
        }, id: ${event.id}`
      )

      const dayBeforeEvent = moment(event.start).subtract(1, 'days')

      if (!event.firstReminderSentAt && moment().isSame(dayBeforeEvent, 'day')) {
        // Don't send reminder if the event has been created the day before the event
        if (moment().isSame(moment(event.createdAt), 'day')) {
          // Do nothing
        } else {
          Notification.send({
            title: 'Event reminder',
            titleFr: "Rappel d'événement",
            message: `"${event.title}" is happening tomorrow`,
            messageFr: `"${event.title}" est demain`,
            projectId: event.project.id,
            users: event.project.users,
            type: 'EVENT_REMINDER',
            data: {
              id: event.id,
            },
          })
        }
        await prisma.event.update({
          where: { id: event.id },
          data: { firstReminderSentAt: moment().toDate() },
        })
      } else if (!event.secondReminderSentAt && moment().isSame(event.start, 'day')) {
        Notification.send({
          title: 'Event reminder',
          titleFr: "Rappel d'événement",
          message: `"${event.title}" is today`,
          messageFr: `"${event.title}" est aujourd'hui`,
          projectId: event.project.id,
          users: event.project.users,
          type: 'EVENT_REMINDER',
          data: {
            id: event.id,
          },
        })
        await prisma.event.update({
          where: { id: event.id },
          data: { secondReminderSentAt: moment().toDate() },
        })
      }

      return Promise.resolve()
    }, Promise.resolve())

    logger.info('Finish processing events')
  } catch (e) {
    logger.error(e)
    throw e
  }
}