import { Injectable } from "@nestjs/common";
import { MessageDto, UserMessage } from "./dto/userMessage.dto";
import { PrismaService } from "../common/prisma/prisma.service";
import {
  Message,
  MessageStatus,
  MessageType,
} from "./entities/message.entity";
import { Chat } from "./entities/chat.entity";

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

  async findOne(id: number): Promise<Message | null> {
    const message = await this.prismaService.message.findUnique({
      where: { id: id },
    });
    return new Message({
      ...message,
      content: {
        text: message.content["text"],
        data: message.content["data"],
      },
    });
  }

  async create(
    userMessage: UserMessage,
    userId: string,
    type: MessageType,
    status: MessageStatus,
  ) {
    const message = new MessageDto(userMessage);
    message.userId = userId;
    message.type = type;
    message.status = status;
    const messageData = {
      ...message,
      content: {
        text: message.content.text,
        data: message.content.data,
      },
    };

    const createdMessage = await this.prismaService.message.create({
      data: messageData,
    });
    return new Message({
      ...createdMessage,
      content: {
        text: createdMessage.content["text"],
        data: createdMessage.content["data"],
      },
    });
  }

  async getChatContext(chat: Chat, contextSize: number) {
    const take = 2 * contextSize;
    let messages = await this.prismaService.message.findMany({
      where: {
        chatId: chat.id,
      },
      orderBy: {
        createdAt: "desc",
      },
      take: take,
    });

    messages = messages.reverse();
    const context = [];
    for (let i = 0; i < messages.length; i += 2) {
      const obj = {
        input: messages[i].content,
        output: i + 1 != messages.length ? messages[i + 1].content : "",
      };
      context.push(obj);
    }

    return context;
  }

  async findForChat(
    chat: Chat,
    queryOptions: {
      pageSize?: number;
      pageOffset?: number;
      startId?: number;
    },
  ) {
    const pageSize = +queryOptions.pageSize || 30;
    const pageOffset = +queryOptions.pageOffset || 0;
    const findArgs = {
      where: { chatId: chat.id },
      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
    }

    const messages = await this.prismaService.message.findMany(findArgs);
    return messages;
  }
}