import { Injectable } from "@nestjs/common";
import { UserMessage } from "./dto/userMessage.dto";
import { PrismaService } from "../common/prisma/prisma.service";
import { MessageService } from "./message.service";
import { Chat, ChatStatus } from "./entities/chat.entity";
import { ChatDto, UpdateChatDto } from "./dto/chat.dto";
import { Message } from "./entities/message.entity";

@Injectable()
export class ChatService {
  constructor(
    private readonly prismaService: PrismaService,
    private readonly messageService: MessageService,
  ) {}

  async create(userMessage: UserMessage, userId: string) {
    const chat = new ChatDto({
      title: userMessage.content.text,
      userId: userId,
      status: ChatStatus.ACTIVE,
      summary: `User Asked: ${userMessage.content.text}`,
    });
    return new Chat(
      await this.prismaService.chat.create({
        data: chat,
      }),
    );
  }

  async findOne(id: number): Promise<Chat | null> {
    const chat = await this.prismaService.chat.findUnique({
      where: { id: id },
    });
    return new Chat(chat);
  }

  async findMessagesForChat(
    chatId: number,
    queryOptions: {
      pageSize?: number;
      pageOffset?: number;
      startID?: number;
    },
  ) {
    const chat = await this.prismaService.chat.findFirstOrThrow({
      where: { id: chatId },
    });
    return (await this.messageService.findForChat(chat, queryOptions)).map(
      (message) =>
        new Message({
          ...message,
          content: {
            text: message.content["text"],
            data: message.content["data"],
          },
        }),
    );
  }

  async update(id: number, updateChatDto: UpdateChatDto) {
    const chat = await this.prismaService.chat.update({
      where: {
        id: id,
        NOT: { status: ChatStatus.DELETED },
      },
      data: updateChatDto,
    });
    return new Chat(chat);
  }

  async ping(id: number) {
    const chat = await this.prismaService.chat.update({
      where: {
        id: id,
        NOT: { status: ChatStatus.DELETED },
      },
      data: { status: ChatStatus.ACTIVE },
    });
    return new Chat(chat);
  }

  async findForUser(
    userId: string,
    queryOptions: {
      pageSize?: number;
      pageOffset?: number;
      startId?: number;
      status?: ChatStatus;
    },
  ) {
    const pageSize = +queryOptions.pageSize || 30;
    const pageOffset = +queryOptions.pageOffset || 0;
    const findArgs = {
      where: {
        userId: userId,
      },
      take: Math.min(100, pageSize), // Limit the number of messages returned
      skip: pageOffset * pageSize, // Offset based on the page number and page size
    };

    if (queryOptions.startId) {
      findArgs["cursor"] = { id: +queryOptions.startId }; // start from ID
    }

    if (queryOptions.status) {
      findArgs.where["status"] = queryOptions.status;
    }

    if (queryOptions.status != ChatStatus.DELETED) {
      findArgs.where["NOT"] = { status: ChatStatus.DELETED };
    }

    const chats = await this.prismaService.chat.findMany(findArgs);
    return chats;
  }
}