// app/api/telegram/lib/prisma-memory.ts
import type { User as TelegramUserType } from 'telegraf/types';
import { prisma } from '@/lib/prisma';

export class PrismaMemory {
    private chatToConversationMap = new Map<number, string>();

    async getOrCreateUser(telegramUser: TelegramUserType) {
        try {
            const telegramId = telegramUser.id.toString();
            let user = await prisma.telegramUser.findUnique({
                where: { telegramId }
            });
            if (!user) {
                user = await prisma.telegramUser.create({
                    data: {
                        telegramId,
                        username: telegramUser.username,
                        firstName: telegramUser.first_name,
                        lastName: telegramUser.last_name,
                    }
                });
                console.log(`Created new user: ${user.id}`);
            } else {
                user = await prisma.telegramUser.update({
                    where: { id: user.id },
                    data: {
                        username: telegramUser.username,
                        firstName: telegramUser.first_name,
                        lastName: telegramUser.last_name,
                        lastInteraction: new Date()
                    }
                });
            }
            return user;
        } catch (error) {
            console.error('Error in getOrCreateUser:', error);
            throw error;
        }
    }

    async getOrCreateConversation(chatId: number, telegramUser: TelegramUserType) {
        try {
            if (this.chatToConversationMap.has(chatId)) {
                return this.chatToConversationMap.get(chatId);
            }

            const user = await this.getOrCreateUser(telegramUser);

            const conversation = await prisma.conversation.findFirst({
                where: {
                    telegramChatId: chatId.toString(),
                    telegramUserId: user.id
                },
                orderBy: { updatedAt: 'desc' }
            });

            if (conversation) {
                this.chatToConversationMap.set(chatId, conversation.id);
                return conversation.id;
            }

            return this.startNewConversation(chatId, user.id);
        } catch (error) {
            console.error('Error in getOrCreateConversation:', error);
            throw error;
        }
    }

    async startNewConversation(chatId: number, userId: string) {
        try {
            const newConversation = await prisma.conversation.create({
                data: {
                    telegramChatId: chatId.toString(),
                    telegramUserId: userId,
                    title: `Conversation ${new Date().toLocaleString('fa-IR')}`
                }
            });

            this.chatToConversationMap.set(chatId, newConversation.id);
            return newConversation.id;
        } catch (error) {
            console.error('Error in startNewConversation:', error);
            throw error;
        }
    }

    async saveMessage(chatId: number, role: string, content: string, telegramUser: TelegramUserType) {
        try {
            const conversationId = await this.getOrCreateConversation(chatId, telegramUser);
            if (!conversationId) throw new Error("Failed to get or create conversation");

            await prisma.message.create({
                data: {
                    role,
                    content,
                    conversationId
                }
            });

            await prisma.conversation.update({
                where: { id: conversationId },
                data: { updatedAt: new Date() }
            });

            await prisma.telegramUser.update({
                where: { telegramId: telegramUser.id.toString() },
                data: { lastInteraction: new Date() }
            });

        } catch (error) {
            console.error('Error in saveMessage:', error);
            throw error;
        }
    }

    async getChatHistory(chatId: number, telegramUser: TelegramUserType) {
        try {
            const conversationId = await this.getOrCreateConversation(chatId, telegramUser);
            if (!conversationId) { // Ensure conversationId is not undefined
                 console.warn(`No conversationId found for chatId: ${chatId}. Returning empty history.`);
                 return '';
            }
            const messages = await prisma.message.findMany({
                where: { conversationId },
                orderBy: { createdAt: 'asc' },
                take: 20
            });

            return messages.map(message => {
                const roleLabel = message.role === 'user' ? 'کاربر' : 'دستیار';
                return `${roleLabel}: ${message.content}\n\n`;
            }).join('');
        } catch (error) {
            console.error('Error in getChatHistory:', error);
            return '';
        }
    }
}