import {
    HttpException,
    HttpStatus,
    Injectable,
} from '@nestjs/common';

import * as dto from './dto/index';
import { Types } from 'mongoose';
import { ModelService } from '../model/model.service';
import { CommonService } from '../common/common.service';
import { RagService } from '../rag/rag.service';
import { CallService } from '../call/call.service';

@Injectable()
export class ChatService {
    constructor(
        private readonly Model: ModelService,
        private readonly CommonService: CommonService,
        private readonly RagService: RagService,
        private readonly CallService: CallService,
    ) {
    }


    async chat_with_ai(body: dto.chat.chatPost) {
        try {
            let { chat_id, text } = body
            if (!chat_id) {
                let chat_create = await this.Model.CallModel.create({ type: "CHAT", last_message: text })
                chat_id = chat_create._id.toString()
            } else {
                await this.Model.CallModel.findByIdAndUpdate(new Types.ObjectId(chat_id), { last_message: text })
            }

            await this.save_chat({ role: "user", text: text, chat_id: chat_id })

            let rag_response = await this.RagService.getAnswerRag(text)

            await this.save_chat({ role: "model", text: rag_response?.answer, chat_id: chat_id })

            return { chat_id: chat_id, ai_response: rag_response?.answer }
        } catch (error) {
            throw error
        }
    }

    async save_chat(data: any) {
        try {
            let { role, text, chat_id } = data

            await this.Model.CallTranscriptModel.create({
                text: text,
                role: role,
                call_id: new Types.ObjectId(chat_id),
                created_at: + new Date()
            })

        } catch (error) {
            throw error
        }
    }


    async end_chat(chat_id: string) {
        try {
            let chat = await this.Model.CallModel.findByIdAndUpdate(new Types.ObjectId(chat_id), { status: "COMPLETE" }, { lean: true })
            await this.CallService.chat_summerize(chat_id)
            return chat
        } catch (error) {
            throw error
        }
    }

    async update_chat_detail(chat_id: string, body: dto.chat.chatUpdateDetail) {
        try {
            let { country_code, phone_no, email, name } = body

            let chat = await this.Model.CallModel.findByIdAndUpdate(new Types.ObjectId(chat_id),
                {
                    ...(phone_no && { phone_no: phone_no }),
                    ...(email && { email:email }),
                    ...(name && { name: name }),
                    ...(country_code && { country_code: country_code }),
                },
                { lean: true })
            return chat
        } catch (error) {
            throw error
        }
    }

}