import * as fs from 'fs';
import { createReadStream, writeFile } from 'fs';
import OpenAI from 'openai';
import * as path from 'path';
import { promisify } from 'util';
import * as uuid from 'uuid';
import { filesDirectory, publicDirectory } from '../SocketData';
import { Method } from '../RouteManager';
import ApiManager, { Registration } from './ApiManager';

export enum Directory {
    parsed_files = 'parsed_files',
    images = 'images',
    videos = 'videos',
    pdfs = 'pdfs',
    text = 'text',
    pdf_thumbnails = 'pdf_thumbnails',
    audio = 'audio',
    csv = 'csv',
}

export function serverPathToFile(directory: Directory, filename: string) {
    return path.normalize(`${filesDirectory}/${directory}/${filename}`);
}

export function pathToDirectory(directory: Directory) {
    return path.normalize(`${filesDirectory}/${directory}`);
}

export function clientPathToFile(directory: Directory, filename: string) {
    return `/files/${directory}/${filename}`;
}

const writeFileAsync = promisify(writeFile);
const readFileAsync = promisify(fs.readFile);

export default class AssistantManager extends ApiManager {
    protected initialize(register: Registration): void {
        const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY, dangerouslyAllowBrowser: true });

        register({
            method: Method.POST,
            subscription: '/uploadPDFToVectorStore',
            secureHandler: async ({ req, res }) => {
                const { urls, threadID, assistantID, vector_store_id } = req.body;

                const csvFilesIds: string[] = [];
                const otherFileIds: string[] = [];
                const allFileIds: string[] = [];

                const fileProcesses = urls.map(async (source: string) => {
                    const fullPath = path.join(publicDirectory, source);
                    const fileData = await openai.files.create({ file: createReadStream(fullPath), purpose: 'assistants' });
                    allFileIds.push(fileData.id);
                    if (source.endsWith('.csv')) {
                        console.log(source);
                        csvFilesIds.push(fileData.id);
                    } else {
                        openai.beta.vectorStores.files.create(vector_store_id, { file_id: fileData.id });
                        otherFileIds.push(fileData.id);
                    }
                });
                try {
                    await Promise.all(fileProcesses).then(() => {
                        res.send({ vector_store_id: vector_store_id, openai_file_ids: allFileIds });
                    });
                } catch (error) {
                    res.status(500).send({ error: 'Failed to process files' + error });
                }
            },
        });

        register({
            method: Method.POST,
            subscription: '/downloadFileFromOpenAI',
            secureHandler: async ({ req, res }) => {
                const { file_id, file_name } = req.body;
                //let files_directory: string;
                let files_directory = '/files/openAIFiles/';
                switch (file_name.split('.').pop()) {
                    case 'pdf':
                        files_directory = '/files/pdfs/';
                        break;
                    case 'csv':
                        files_directory = '/files/csv/';
                        break;
                    case 'png':
                    case 'jpg':
                    case 'jpeg':
                        files_directory = '/files/images/';
                        break;
                    default:
                        break;
                }

                const directory = path.join(publicDirectory, files_directory);

                if (!fs.existsSync(directory)) {
                    fs.mkdirSync(directory);
                }
                const file = await openai.files.content(file_id);
                const new_file_name = `${uuid.v4()}-${file_name}`;
                const file_path = path.join(directory, new_file_name);
                const file_array_buffer = await file.arrayBuffer();
                const bufferView = new Uint8Array(file_array_buffer);
                try {
                    const written_file = await writeFileAsync(file_path, bufferView);
                    console.log(written_file);
                    console.log(file_path);
                    console.log(file_array_buffer);
                    console.log(bufferView);
                    const file_object = new File([bufferView], file_name);
                    //DashUploadUtils.upload(file_object, 'openAIFiles');
                    res.send({ file_path: path.join(files_directory, new_file_name) });
                    /* res.send( {
                        source: "file",
                        result: {
                                  accessPaths: {
                                      agnostic: {client: path.join('/files/openAIFiles/', `${uuid.v4()}-${file_name}`)}
                                  },
                                  rawText: "",
                                  duration: 0,
                              },
                    } ); */
                } catch (error) {
                    res.status(500).send({ error: 'Failed to write file' + error });
                }
            },
        });
    }
}