export class ChunkedFileUploadUtilities {
    chunkFile(file: Blob | string, chunkSize: number, contentTypeMime: string): ChunkFileResult {
        let fileInternal: Blob;

        if (typeof file === "string")
            fileInternal = this.base64ToBlob(file, chunkSize, contentTypeMime);
        else {
            fileInternal = file as Blob;
        }

        const fileSize = fileInternal.size;
        const result: Array<FileUploadChunk> = [];
        let chunkOrdinal = 0;
        let offset = 0;
        let currentOffset = chunkSize;

        while (offset <= fileSize) {
            const chunk = fileInternal.slice(offset, currentOffset, contentTypeMime);
            offset = currentOffset;
            currentOffset = currentOffset + chunkSize;

            result.push({
                ordinal: chunkOrdinal,
                content: chunk
            });

            chunkOrdinal++;
        }

        return {
            chunks: result,
            totalChunksCount: result.length,
            fileTotalSize: fileSize
        };
    }

    private base64ToBlob(base64String, chunkSize, contentType = ""): Blob {
        const byteCharacters = atob(base64String);
        const byteArrays = [];
        for (let offset = 0; offset < byteCharacters.length; offset += chunkSize) {
            const slice = byteCharacters.slice(offset, offset + chunkSize);
            const byteNumbers = new Array(slice.length);
            for (let i = 0; i < slice.length; i++) {
                byteNumbers[i] = slice.charCodeAt(i);
            }
            const byteArray = new Uint8Array(byteNumbers);
            byteArrays.push(byteArray);
        }

        const blob = new Blob(byteArrays, { type: contentType });
        return blob;
    }
}

export interface FileUploadChunk {
    ordinal: number,
    content: Blob
}

export interface ChunkFileResult {
    chunks: Array<FileUploadChunk>,
    totalChunksCount: number,
    fileTotalSize: number
}