import { LocalStorageKeys } from "@common/Constants";
import { getAsyncStorageItem, setAsyncStorageItem } from "@components/utlis/commonFunctions";
import { logError } from "@components/utlis/errorUtils";

export enum FILE_Enums {
    FILE_SIZE,
    CREATED_AT,
    UPDATED_AT,
};

export enum MimeTypes {
    IMAGE = 'image',
    VIDEO = 'video',
    AUDIO = 'audio',
    TEXT = 'text',
    PDF = 'pdf',
    ZIP = 'ZIP',
    OTHER = 'other',
};

export const mimeTypes: { [key in MimeTypes]: string[] } = {
    [MimeTypes.IMAGE]: ['image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml', 'image/bmp', 'image/tiff', 'image/x-icon', 'image/vnd.microsoft.icon', 'image/vnd.wap.wbmp', 'image/x-xbitmap'],
    [MimeTypes.VIDEO]: ['video/mp4', 'video/mpeg', 'video/quicktime'],
    [MimeTypes.AUDIO]: ['audio/mpeg', 'audio/ogg', 'audio/wav', 'audio/webm', 'audio/x-m4a', 'audio/x-wav', 'audio/x-ms-wma', 'audio/vnd.rn-realaudio' ],
    [MimeTypes.TEXT]: ['text/plain', 'text/html', 'text/css'],
    [MimeTypes.PDF]: ['application/pdf'],
    [MimeTypes.ZIP]: ['application/zip'],
    [MimeTypes.OTHER]: []
};

export interface FileEntry {
    path: string;
    size: number;
    createdAt: number;
    updateAt: string;
    mimeType: MimeTypes;
    zipped: boolean;
    name: string;
    startOffset?: number;
    endOffset?: number;
    type?: 'IMAGES' | 'VIDEOS' | 'AUDIOS';
};


export let filesStore = {} as {
    [id: string]: FileEntry
}; 

getAsyncStorageItem(LocalStorageKeys.IMAGE_FILES, true)
    .then((result) => {
        filesStore = result || {};
    })
    .catch((error) => {
        logError(error, 'Error while fetching files from local storage');
    });


const FileDBSideEffects = () => {

    setAsyncStorageItem(LocalStorageKeys.IMAGE_FILES, filesStore);
}



export const FileDB = {
    getFiles: (filterFn: (FileEntry: FileEntry) => Boolean) => {


        if (typeof filterFn !== 'function') {
            throw new Error('"filterFn" must be a function');
        }

        let filteredEntries = [];

        Object.entries(filesStore).forEach(([key, value]) => {
            if (filterFn(value)) {
                filteredEntries.push(value);
            }
        });


        return filteredEntries;
    },

    addFiles: (files: Array<FileEntry> | FileEntry) => {
        const add = (file: FileEntry) => {
            if (!filesStore[file.path]) {
                filesStore[file.path] = {
                    ...file,
                    zipped: false
                };
            }
        }

        if (Array.isArray(files)) {
            files.forEach(add);
            FileDBSideEffects();
            return;
        }

        add(files)
        FileDBSideEffects();
    },


    updateFile: (path: string, values: any) => {
        if (!filesStore[path]) {
            throw new Error('File not found');
        }
        filesStore[path] = { ...filesStore[path], ...values };
        FileDBSideEffects();
    },

    markFileZipped: (files: Array<FileEntry> | FileEntry) => {
        const update = (file: FileEntry) => {
            if (!filesStore[file.path]) {
                throw new Error('File not found');
            }
            filesStore[file.path] = {
                ...filesStore[file.path],
                zipped: true
            }
        }

        if (Array.isArray(files)) {
            files.forEach(update);
            FileDBSideEffects();
            return;
        }

        update(files);
        FileDBSideEffects();
    },
    unlinkFile: (file: Array<FileEntry> | string) => {

        if (Array.isArray(file)) {
            file.forEach((singleFile) => {
                if (!filesStore[singleFile.path]) {
                    throw new Error('File not found');
                }
                delete filesStore[singleFile.path];
            });
            FileDBSideEffects();
            return;
        }

        if (!filesStore[file]) {
            throw new Error('File not found');
        }
        delete filesStore[file];
        FileDBSideEffects();
    }

};


const filterMimeType = (file: FileEntry, type: MimeTypes) => mimeTypes[type].includes(file.mimeType);


export const filterFunctions = {
    allUnzipFiles: () => (file: FileEntry) => !file.zipped && file.mimeType !== MimeTypes.ZIP,

    bySize: (size: number, type: MimeTypes) => (file: FileEntry) => file.size > size && filterMimeType(file, type),

    recentFile: (createdAt: Date, type: MimeTypes) => (file: FileEntry) => file.createdAt > createdAt.toISOString() && filterMimeType(file, type),

    byMimeType: (mimeType: MimeTypes) => (file: FileEntry) => filterMimeType(file, mimeType)
};