import { Express } from 'express'
import * as SendBirdController from '../controllers/sendbird'
import * as SendBirdUtils from '../utils/sendbird'
import * as Auth from '../utils/auth'
import { logger } from '../utils/logger'
import { prismaClient as prisma } from '../prismaClient'
import { handleWebhook } from '../controllers/sendbird/handleWebhook'

type CreatedChannelType = {
  publicChannel: SendBirdUtils.Channel
  privateChannel: SendBirdUtils.Channel
} | null

export default (server: Express) => {
  server.post('/api/sendbird/v7/webhook', handleWebhook)
  server.post('/api/sendbird', handleWebhook)
  server.post('/api/sendbird/users/:userId', async (req, res) => {
    const { userId } = req.params
    const user = await prisma.user.findOne({
      where: { id: userId },
      select: {
        id: true,
        firstName: true,
        lastName: true,
        avatar: {
          select: {
            url: true,
          },
        },
      },
    })

    const sendBirdUser = await SendBirdController.createUser({
      userId: user.id,
      nickname: `${user.firstName} ${user.lastName}`,
      profileUrl: user.avatar?.url || '',
    })

    return res.status(200).json(sendBirdUser)
  })

  server.post('/api/sendbird/channels/residents/walter/createAndSendMessage', async (req, res) => {
    try {
      const currentUserId = await Auth.getUserIdRest(req)
      const { message } = req.body

      const channel = await SendBirdController.createOrGetWalterSupportChannel({
        otherUserId: currentUserId,
      })

      if (message) {
        await SendBirdController.sendMessage({
          message,
          channelUrl: channel.channel_url,
          fromSendbirdUserId: currentUserId,
        })
      }

      res.status(200).json(channel)
    } catch (error) {
      logger.error(error)
      res.status(500).send(error)
    }
  })

  server.post('/api/sendbird/channels/residents/service/createAndSendMessage', async (req, res) => {
    try {
      const currentUserId = await Auth.getUserIdRest(req)
      const { message, serviceId } = req.body

      const channel = await SendBirdController.createOrGetServiceProviderChannel({
        serviceId,
        otherUserId: currentUserId,
      })

      if (message) {
        await SendBirdController.sendMessage({
          message,
          channelUrl: channel.channel_url,
          fromSendbirdUserId: currentUserId,
        })
      }

      res.status(200).json(channel)
    } catch (error) {
      logger.error(error)
      res.status(500).send(error)
    }
  })

  server.post('/api/sendbird/channels/residents/manager/createAndSendMessage', async (req, res) => {
    try {
      const currentUserId = await Auth.getUserIdRest(req)
      const { propertyId, projectId, message } = req.body

      const [publicChannel] = await SendBirdController.createOrGetManagerChannel({
        propertyId,
        projectId,
      })

      // Make sure the resident is in the channel
      if (publicChannel.members?.some((member) => member.user_id !== currentUserId)) {
        await SendBirdController.addUsersToChannel({
          userIds: [currentUserId],
          channelUrl: publicChannel.channel_url,
        })
      }

      if (message) {
        await SendBirdController.sendMessage({
          message,
          projectId,
          channelUrl: publicChannel.channel_url,
          fromSendbirdUserId: currentUserId,
        })
      }

      res.status(200).json(publicChannel)
    } catch (error) {
      logger.error(error)
      res.status(500).send(error)
    }
  })

  server.post('/api/sendbird/channels/createAndSendMessage', async (req, res) => {
    try {
      const currentUserId = await Auth.getUserIdRest(req)
      const { propertiesIds, projectId, message, fromSendbirdUserId, files = [] } = req.body

      const createdChannels: CreatedChannelType[] = await Promise.all(
        propertiesIds.map(async (propertyId) => {
          const [
            publicChannel,
            privateChannel,
          ] = await SendBirdController.createOrGetManagerChannel({
            propertyId,
            projectId,
          })

          // Protection in case the channel already existed but the resident wasn't in it
          if (!publicChannel.members.some((member) => member.user_id === fromSendbirdUserId)) {
            await SendBirdController.addUsersToChannel({
              userIds: [fromSendbirdUserId],
              channelUrl: publicChannel.channel_url,
            })
          }

          if (message || files.length > 0) {
            await Promise.all([
              ...(message
                ? [
                    SendBirdController.sendMessage({
                      message,
                      projectId,
                      channelUrl: publicChannel.channel_url,
                      fromSendbirdUserId,
                      messageData: JSON.stringify({ sender: currentUserId }),
                    }),
                  ]
                : []),
              ...(files
                ? [
                    SendBirdController.sendMessage({
                      fromSendbirdUserId: fromSendbirdUserId,
                      attachments: files,
                      projectId: projectId,
                      channelUrl: publicChannel.channel_url,
                      messageData: JSON.stringify({ sender: currentUserId }),
                    }),
                  ]
                : []),
            ])
          }

          if (publicChannel || privateChannel) {
            return Promise.resolve({
              privateChannel,
              publicChannel,
            })
          }

          return Promise.resolve(null)
        })
      )

      const validCreatedChannels = createdChannels.filter(Boolean)

      res.status(200).json({
        createdPublicChannelUrls: validCreatedChannels.map((c) => c.publicChannel.channel_url),
        createdPrivateChannelUrls: validCreatedChannels.map((c) => c.privateChannel.channel_url),
      })
    } catch (error) {
      logger.error(error)
      res.status(500).send(error)
    }
  })
}