import { schema } from 'nexus'
import { TaskStatusOrderByInput, TaskStatusWhereInput } from 'nexus-plugin-prisma/client'
import * as Auth from '../../utils/auth'
import { prismaClient as prisma } from '../../prismaClient'

// Keep for later please
// const reorderArray = (event, originalArray) => {
//   const movedItem = originalArray.find((item, index) => index === event.oldIndex)
//   const remainingItems = originalArray.filter((item, index) => index !== event.oldIndex)

//   const reorderedItems = [
//     ...remainingItems.slice(0, event.newIndex),
//     movedItem,
//     ...remainingItems.slice(event.newIndex)
//   ]

//   return reorderedItems
// }

const reorderPosition = async (taskId, newPosition, oldPosition, userId) => {
  const user = await prisma.user.findOne({
    where: { id: userId },
    select: {
      id: true,
      title: true,
      managingCompany: {
        select: {
          tasksStatuses: {
            select: {
              id: true,
              orderPosition: true,
            },
            orderBy: {
              orderPosition: 'asc',
            },
          },
        },
      },
    },
  })

  const taskStatuses = user.managingCompany.tasksStatuses

  if (!oldPosition) {
    taskStatuses.forEach((taskStatus) => {
      if (taskStatus.orderPosition >= newPosition && taskStatus.id !== taskId) {
        taskStatus.orderPosition += 1
      }
    })
  } else {
    taskStatuses.forEach((taskStatus) => {
      if (taskStatus.orderPosition <= newPosition && taskStatus.id !== taskId) {
        taskStatus.orderPosition = Math.max(taskStatus.orderPosition - 1, 1)
      }
    })
  }

  // Make sure everyone has an order position
  let lastPosition = Math.max(...taskStatuses.map((t) => t.orderPosition)) || 1
  taskStatuses.forEach((taskStatus) => {
    if (!taskStatus.orderPosition === null) {
      taskStatus.orderPosition = lastPosition + 1
      lastPosition += 1
    }
  })

  // Make sure that they are all following eachother
  taskStatuses
    .sort((a, b) => a.orderPosition - b.orderPosition)
    .forEach((taskStatus, index) => {
      taskStatus.orderPosition = index + 1
    })

  await Promise.all(
    taskStatuses.map(async (taskStatus) => {
      await prisma.taskStatus.update({
        where: {
          id: taskStatus.id,
        },
        data: {
          orderPosition: taskStatus.orderPosition,
        },
      })
    })
  )
}

export const TaskStatus = schema.objectType({
  name: 'TaskStatus',
  definition(t) {
    t.model.id()
    t.model.createdAt()
    t.model.updatedAt()
    t.model.title()
    t.model.description()
    t.model.color()
    t.model.actAsComplete()
    t.model.orderPosition()
    t.model.managingCompany()
    t.model.tasks()
  },
})

export const TaskStatusQueries = schema.extendType({
  type: 'Query',
  definition(t) {
    t.crud.taskStatus()
    t.crud.taskStatuses({ filtering: true, ordering: true })

    t.field('taskStatuses', {
      type: 'TaskStatus',
      list: true,
      args: {
        where: schema.arg({ type: 'TaskStatusWhereInput' }),
        orderBy: schema.arg({ type: 'TaskStatusOrderByInput', list: true }),
        first: schema.arg({ type: 'Int' }),
        skip: schema.arg({ type: 'Int' }),
      },
      resolve: (
        parent,
        {
          where,
          orderBy,
          first,
          skip,
        }: {
          where?: TaskStatusWhereInput
          orderBy?: TaskStatusOrderByInput[]
          first?: number
          skip?: number
        },
        ctx: NexusContext
      ) => {
        return ctx.prisma.taskStatus.findMany({
          where: where,
          ...(orderBy?.length > 0 && { orderBy: orderBy[0] }),
          take: first,
          skip: skip,
        })
      },
    })
  },
})

export const TaskStatusMutation = schema.extendType({
  type: 'Mutation',
  definition: (t) => {
    t.crud.deleteOneTaskStatus({ alias: 'deleteTaskStatus' })
    t.crud.updateOneTaskStatus({ alias: 'updateTaskStatus' })
    t.crud.createOneTaskStatus({ alias: 'createTaskStatus' })

    t.field('createTaskStatus', {
      type: 'TaskStatus',
      args: {
        data: schema.arg({ type: 'TaskStatusCreateInput' }),
      },
      resolve: async (parent, { data }, ctx: NexusContext) => {
        const id = Auth.getUserId(ctx)

        const createdTaskStatus = await ctx.prisma.taskStatus.create({ data })

        await reorderPosition(createdTaskStatus.id, createdTaskStatus.orderPosition, null, id)

        return ctx.prisma.taskStatus.findOne({ where: { id: createdTaskStatus.id } })
      },
    })

    t.field('updateTaskStatus', {
      type: 'TaskStatus',
      args: {
        data: schema.arg({ type: 'TaskStatusUpdateInput' }),
        where: schema.arg({ type: 'TaskStatusWhereUniqueInput' }),
      },
      resolve: async (parent, { where, data }, ctx: NexusContext) => {
        const id = Auth.getUserId(ctx)

        const [updatedTaskStatus, oldTaskStatus] = await Promise.all([
          ctx.prisma.taskStatus.update({ where, data }),
          ctx.prisma.taskStatus.findOne({ where }),
        ])

        if (data.orderPosition) {
          await reorderPosition(
            updatedTaskStatus.id,
            data.orderPosition,
            oldTaskStatus.orderPosition,
            id
          )
        }

        return ctx.prisma.taskStatus.findOne({ where: { id: updatedTaskStatus.id } })
      },
    })
  },
})