import { schema } from 'nexus'
import * as Auth from '../../utils/auth'
import GeneralUtils from '../../utils/general'
import * as SegmentController from '../../controllers/segment'
import {
  Property,
  PropertyGetPayload,
  ProjectGetPayload,
  FolderWhereInput,
} from 'nexus-plugin-prisma/client'
import * as FolderController from '../../controllers/folder'

export const Folder = schema.objectType({
  name: 'Folder',
  definition(t) {
    t.model.id()
    t.model.createdAt()
    t.model.updatedAt()
    t.model.name()
    t.model.description()
    t.model.hideFromTenants()
    t.model.hiddenForTenants()
    t.model.forOwnersOnly()
    t.model.forBoardMembersOnly()
    t.model.sendNotification()
    t.model.folderParent()
    t.model.project()
    t.model.other_Folder()
    t.model.files()
    t.model.segments()
  },
})

type PropertyWithRelations = PropertyGetPayload<{
  select: {
    building: {
      select: {
        id: true
      }
    }
  }
}>

type ProjectWithRelations = ProjectGetPayload<{
  select: {
    id: true
    segments: {
      select: {
        id: true
      }
    }
  }
}>

export const FolderMutation = schema.extendType({
  type: 'Mutation',
  definition: (t) => {
    t.crud.deleteOneFolder({ alias: 'deleteFolder' })
    t.crud.updateOneFolder({ alias: 'updateFolder' })
    t.crud.createOneFolder({ alias: 'createFolder' })

    t.field('deleteFolder', {
      type: 'Folder',
      args: { where: schema.arg({ type: 'FolderWhereUniqueInput', required: true }) },
      resolve: async (_, { where }) => {
        return await FolderController.deleteFolderCascade(where.id)
      },
    })
  },
})

export const FolderQuery = schema.extendType({
  type: 'Query',
  definition(t) {
    t.crud.folder()
    t.crud.folders({ filtering: true, ordering: true })

    t.field('folders', {
      type: 'Folder',
      list: true,
      args: { where: schema.arg({ type: 'FolderWhereInput' }) },
      resolve: async (parent, args, ctx: NexusContext) => {
        const userId = Auth.getUserId(ctx)
        const [user, folders] = await Promise.all([
          ctx.prisma.user.findOne({
            where: { id: userId },
            select: {
              id: true,
              role: true,
              projectsBoardMember: {
                select: {
                  id: true,
                },
              },
              properties: {
                select: {
                  id: true,
                  building: true,
                },
              },
              currentProject: {
                select: {
                  id: true,
                  building: {
                    select: {
                      id: true,
                    },
                  },
                },
              },
            },
          }),
          ctx.prisma.folder.findMany({
            where: args.where as FolderWhereInput,
            select: {
              id: true,
              forOwnersOnly: true,
              forBoardMembersOnly: true,
              segments: {
                select: {
                  id: true,
                  users: {
                    select: {
                      id: true,
                    },
                  },
                  properties: {
                    select: {
                      building: {
                        select: {
                          id: true,
                        },
                      },
                      users: {
                        select: {
                          id: true,
                        },
                      },
                      owners: {
                        select: {
                          id: true,
                        },
                      },
                    },
                  },
                },
              },
            },
          }),
        ])

        // Make sure to not return owners or board members only folders
        if (user.role === 'RESIDENT') {
          let filteredFilters = []

          filteredFilters = await Promise.all(
            folders.map(async (folder) =>
              folder.segments.length
                ? (await SegmentController.getUsersForSegments(folder.segments)).some(
                    (u) => u.id === userId
                  )
                  ? folder
                  : null
                : folder.forOwnersOnly
                ? user.properties.some(
                    (property: Partial<Property>) =>
                      (<PropertyWithRelations>property).building.id ===
                      user.currentProject.building.id
                  )
                  ? folder
                  : null
                : folder.forBoardMembersOnly
                ? user.projectsBoardMember.some(
                    (p: Partial<ProjectWithRelations>) => p.id === user.currentProject.id
                  )
                  ? folder
                  : null
                : folder
            )
          )
        }

        return ctx.prisma.folder.findMany({
          where: { id: { in: folders.map((f) => f.id) } },
        })
      },
    })
  },
})