import { Notification, NotificationKind } from "@prisma/client";

import { endOfDay } from "date-fns";

import { prisma } from "@app/lib/prisma";

import { APP_TIMEZONE } from "@app/lib/appTime";

import { logger } from "@app/lib/logger";

import { sendPushNotification } from "@app/lib/sendPushNotification";

import {

  publicNotificationSelect,

  PublicNotification,

} from "@app/lib/serializers/notification";

export type CreateNotificationInput = {

  userId: number;

  kind: NotificationKind;

  title: string;

  body: string;

  scheduledFor: Date;

  regimenId?: number | null;

};

const endOfAppDay = (scheduledFor: Date): Date =>

  endOfDay(scheduledFor, { in: APP_TIMEZONE });

// The only place a kind's behaviour is described: how long it stays relevant,

// and where tapping it should lead

type NotificationRule = {

  expiresAt: (scheduledFor: Date) => Date | null;

  screen?: string;

};

const notificationRules: Record<NotificationKind, NotificationRule> = {

  [NotificationKind.DAILY_REMINDER]: {

    expiresAt: endOfAppDay,

    screen: "moods",

  },

  [NotificationKind.MEDICINE_REMINDER]: {

    expiresAt: endOfAppDay,

    screen: "medicine-regimens",

  },

  [NotificationKind.INSIGHT_ALERT]: {

    expiresAt: () => null,

  },

};

export const createNotification = async (

  input: CreateNotificationInput

): Promise<Notification | null> => {

  const { userId, kind, title, body, scheduledFor, regimenId = null } = input;

  const user = await prisma.user.findUnique({

    where: { id: userId },

    select: { pushToken: true, pushEnabled: true },

  });

  if (!user) {

    logger.warn({ userId, kind }, "[notification] user not found, skipping");

    return null;

  }

  const rule = notificationRules[kind];

  const notification = await prisma.notification.create({

    data: {

      userId,

      kind,

      title,

      body,

      scheduledFor,

      regimenId,

      expiresAt: rule.expiresAt(scheduledFor),

    },

  });

  if (!user.pushEnabled || !user.pushToken) {

    logger.info(

      { notificationId: notification.id, userId, kind },

      "[notification] stored without push"

    );

    return notification;

  }

  const data = {

    notificationId: notification.id,

    ...(rule.screen ? { screen: rule.screen } : {}),

    ...(regimenId !== null ? { regimenId } : {}),

  };

  try {

    await sendPushNotification({

      token: user.pushToken,

      title,

      body,

      data,

    });

  } catch (error) {

    logger.error(

      { notificationId: notification.id, userId, err: error },

      "[notification] push failed"

    );

    return notification;

  }

  logger.info(

    { notificationId: notification.id, userId, kind },

    "[notification] push sent"

  );

  return prisma.notification.update({

    where: { id: notification.id },

    data: { pushedAt: new Date() },

  });

};

const DEFAULT_NOTIFICATIONS_LIMIT = 30;

export type NotificationsPage = {

  notifications: PublicNotification[];

  nextCursor: number | null;

};

// Ids are monotonic, so ordering by id is newest-first and gives the cursor a

// stable, unique key. One extra row is fetched to know whether more remain

export const getNotificationsByUserId = async (

  userId: number,

  params?: { limit?: number; cursor?: number }

): Promise<NotificationsPage> => {

  const limit = params?.limit ?? DEFAULT_NOTIFICATIONS_LIMIT;

  const rows = await prisma.notification.findMany({

    where: {

      userId,

      ...(params?.cursor !== undefined && { id: { lt: params.cursor } }),

    },

    orderBy: { id: "desc" },

    take: limit + 1,

    select: publicNotificationSelect,

  });

  const hasMore = rows.length > limit;

  const notifications = hasMore ? rows.slice(0, limit) : rows;

  return {

    notifications,

    nextCursor: hasMore ? notifications[notifications.length - 1].id : null,

  };

};