import { Body, Controller, Delete, Get, Param, Post, Query, Request, UploadedFile, UseGuards, UseInterceptors } from '@nestjs/common';
import { ApiBearerAuth, ApiBody, ApiConsumes, ApiTags } from '@nestjs/swagger';
import * as Multer from 'multer';

import { KnowledgeBaseService } from './knowledge_base.service';
import { AuthGuard } from '../../auth/auth.guard';
import * as dto from './dto';
import { FileInterceptor } from '@nestjs/platform-express';


@ApiTags('Admin knowledge Base')
@Controller('admin/knowledge-base')
export class KnowledgeBaseController {
    constructor(
        private readonly KnowledgeBaseService: KnowledgeBaseService
    ) { }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Post()
    async knowledge_base(@Body() body: dto.knowledgebase.knowledgeBaseCreate, @Request() req: any) {
        try {
            const resp = await this.KnowledgeBaseService.knowledge_base_create(body, req)
            return resp;
        } catch (error) {
            throw error
        }
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Get()
    async knowledge_base_list(@Query() body: dto.knowledgebase.getKnowledgeBase, @Request() req: any) {
        try {
            const resp = await this.KnowledgeBaseService.knowledge_base_get(body, req)
            return resp;
        } catch (error) {
            throw error
        }
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Get("/:_id/documents")
    async knowledge_base_documents(@Param("_id") knowledge_base_id: string, @Query() body: dto.knowledgebase.getKnowledgeBase, @Request() req: any) {
        try {
            const resp = await this.KnowledgeBaseService.knowledge_base_documents(knowledge_base_id, body, req)
            return resp;
        } catch (error) {
            throw error
        }
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Delete("/documents/:_id")
    async documents_delete(@Param("_id") document_id: string, @Request() req: any) {
        try {
            let res = await this.KnowledgeBaseService.document_delete(document_id, req)
            return res
        } catch (error) {
            throw error
        }
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Delete("/:_id")
    async knowledge_base_delete(@Param("_id") knowledge_base_id: string, @Request() req: any) {
        try {
            let res = await this.KnowledgeBaseService.knowledge_base_delete(knowledge_base_id, req)
            return res
        } catch (error) {
            throw error
        }
    }


    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Post("url-upload")
    async scrapAndUpload(@Body() body: dto.knowledgebase.urlUpload) {
        try {
            const resp = await this.KnowledgeBaseService.scrapAndUpload(body?.url, body?.title, body?.knowledge_base_id, body?.depth)
            return {
                message: 'Document processed successfully',
                extract_url: resp
            };
        } catch (error) {
            throw error
        }
    }

    @UseGuards(AuthGuard)
    @ApiBearerAuth('authorization')
    @Post("text-upload")
    async textUpload(@Body() body: dto.knowledgebase.AddTextDto, @Request() req: any) {
        try {
            let res = await this.KnowledgeBaseService.textUpload(body?.text, body?.title, body?.knowledge_base_id)
            return res
        } catch (error) {
            throw error
        }
    }

    @ApiBearerAuth('authorization')
    @ApiConsumes('multipart/form-data')
    @ApiBody({ type: dto.knowledgebase.Upload })
    @UseInterceptors(FileInterceptor('file'))
    @Post("pdf-upload")
    async pdfUpload(@UploadedFile() file: Multer.file, @Body() body: dto.knowledgebase.Upload, @Request() req: any) {
        try {
            let { knowledge_base_id } = req.body
            knowledge_base_id = body?.knowledge_base_id ? body?.knowledge_base_id : knowledge_base_id ? knowledge_base_id : null

            let res = await this.KnowledgeBaseService.pdfUpload(file, knowledge_base_id)
            return {
                message: 'Document processed successfully',
                chunks: res.length,
            };
        } catch (error) {
            throw error
        }
    }

    // @Get("vector/:document_id")
    // async document_id(@Param('document_id') document_id: string, @Query() body: any) {
    //     try {
    //         const { query } = body;
    //         let res = await this.KnowledgeBaseService.getDataFromMilvus(query, document_id)
    //         return res
    //     } catch (error) {
    //         throw error
    //     }
    // }
}