import moment from 'moment'
import { User } from 'nexus-plugin-prisma/client'
import { logger } from '../../utils/logger'
import * as UserController from '../user'
import { prismaClient as prisma } from '../../prismaClient'

export async function createManagingCompany({ data }) {
  logger.info('♻️  Creating managing company')

  if (!data) {
    throw new Error('Can\'t create managing company without data')
  }

  const { users, ...managingCompanyData } = data

  // MAKE SURE USERS DOESN'T EXISTS
  if (users?.create) {
    const existingUsers: Partial<User>[] = await Promise.all(
      users.create.map((user) =>
        UserController.querySingleUser({
          email: user.email,
        })
      )
    )

    const existingUser: Partial<User> = existingUsers.find(Boolean)

    if (existingUser) {
      throw new Error(`Already someone with email ${existingUser.email}`)
    }
  }

  // CREATE ROLE
  const managingCompanyRole = await prisma.managingCompanyRole.create({
    data: {
      title: 'Admin',
      permissions: {
        set: [
          'MANAGING_COMPANY_INFO_READ',
          'MANAGING_COMPANY_INFO_WRITE',
          'ROLES_READ',
          'ROLES_WRITE',
          'ACCOUNTS_READ',
          'ACCOUNTS_WRITE',
          'NOTIFICATION_READ',
          'NOTIFICATION_WRITE',
          'CALENDAR_READ',
          'CALENDAR_WRITE',
          'CONTACT_READ',
          'CONTACT_WRITE',
          'RULE_READ',
          'RULE_WRITE',
          'AMENITY_READ',
          'AMENITY_WRITE',
          'MAIL_READ',
          'MAIL_WRITE',
          'CHAT_READ',
          'CHAT_WRITE',
          'USER_READ',
          'USER_WRITE',
          'DELIVERY_READ',
          'DELIVERY_WRITE',
          'WORK_ORDER_READ',
          'WORK_ORDER_WRITE',
          'VALET_READ',
          'VALET_WRITE',
          'DOOR_ACCESS_READ',
          'DOOR_ACCESS_WRITE',
          'SMART_SPEAKER_READ',
          'SMART_SPEAKER_WRITE',
          'FILE_READ',
          'FILE_WRITE',
          'SALE_READ',
          'SALE_WRITE',
          'INTERCHAT_READ',
          'INTERCHAT_WRITE',
          'NOTE_WRITE',
          'NOTE_READ',
          'SEGMENT_WRITE',
          'SEGMENT_READ',
          'MANAGING_COMPANY_WRITE',
          'MANAGING_COMPANY_READ',
          'PROJECT_WRITE',
          'PROJECT_READ',
          'OFFENSE_READ',
          'OFFENSE_WRITE',
          'CAMERA_READ',
          'CAMERA_WRITE',
          'TASK_WRITE',
          'TASK_READ',
        ],
      },
    },
  })

  // CREATE MANAGING COMPANY
  const managingCompany = await prisma.managingCompany.create({
    data: {
      ...managingCompanyData,
      roles: {
        connect: [{ id: managingCompanyRole.id }],
      },
      businessHours: {
        create: new Array(7).fill(0).map((_, index) => ({
          dayOfWeek: index,
          openAtMS: 1000 * 60 * 60 * 9,
          openAt: moment().hours(9).minutes(0).seconds(0).toDate(),
          closeAtMS: 1000 * 60 * 60 * 17,
          closeAt: moment().hours(17).minutes(0).seconds(0).toDate(),
          isClosed: index === 0 || index === 6,
        })),
      },
      tasksCategories: {
        create: [
          {
            title: 'Work order',
          },
          {
            title: 'Access Keys',
          },
          {
            title: 'Other',
          },
        ],
      },
      tasksStatuses: {
        create: [
          {
            title: 'To do',
            description: 'Listing of all the tasks that need to be done',
            color: '#ffa500',
            actAsComplete: false,
          },
          {
            title: 'Done',
            description: 'Listing of all the tasks that are done',
            color: '#00ff00',
            actAsComplete: true,
          },
        ],
      },
    },
  })

  // CREATE USERS
  await Promise.all(
    [
      ...(users?.create || []),
      {
        firstName: 'Walter',
        lastName: 'Admin',
        email: `admin.${moment().unix()}@usewalter.com`,
        password: process.env.DEFAULT_MANAGER_PASSWORD,
      },
    ]
      .map((user) => ({
        ...user,
        role: 'MANAGER',
        managingCompany: {
          connect: {
            id: managingCompany.id,
          },
        },
        managingCompanyRole: {
          connect: {
            id: managingCompanyRole.id,
          },
        },
      }))
      .map((user) => UserController.createUser(user))
  )

  logger.info('✅ Created new managing company')

  return managingCompany
}