class Parser {
    private array: Uint8Array;
    // private token: null;
    private current: string | null;
    public i: number;
    private boundary: string;

    public constructor(arraybuf: Uint8Array, boundary: string) {
        this.array = arraybuf;
        // this.token = null;
        this.current = null;
        this.i = 0;
        this.boundary = boundary;
    }

    public skipPastNextBoundary(): boolean {
        let boundaryIndex = 0;
        let isBoundary = false;

        while (!isBoundary) {
            if (this.next() === null) {
                return false;
            }

            if (this.current === this.boundary[boundaryIndex]) {
                boundaryIndex++;
                if (boundaryIndex === this.boundary.length) {
                    isBoundary = true;
                }
            } else {
                boundaryIndex = 0;
            }
        }

        return true;
    }

    public parseHeader() {
        let header = '';
        const skipUntilNextLine = () => {
            header += this.next();
            while (this.current !== '\n' && this.current !== null) {
                header += this.next();
            }
            if (this.current === null) {
                return null;
            }
        };

        let hasSkippedHeader = false;
        while (!hasSkippedHeader) {
            skipUntilNextLine();
            header += this.next();
            if (this.current === '\r') {
                header += this.next(); // skip
            }

            if (this.current === '\n') {
                hasSkippedHeader = true;
            } else if (this.current === null) {
                return null;
            }
        }

        return header;
    }

    public next() {
        if (this.i >= this.array.byteLength) {
            this.current = null;
            return null;
        }

        this.current = String.fromCharCode(this.array[this.i]);
        this.i++;
        return this.current;
    }
}

function buf2String(buf: Uint8Array): string {
    return Array.from(buf)
        .map((byte) => String.fromCharCode(byte))
        .join('');
}

interface Section {
    header?: Record<string, string>;
    text?: string;
    file?: Blob;
    fileName?: string;
    name?: string;
    bodyStart?: number;
    end?: number;
    headerStart?: number;
}

function processSections(arraybuf: Uint8Array, sections: Section[]): Section[] {
    for (let i = 0; i !== sections.length; ++i) {
        const section = sections[i];
        if (section.header!['content-type'] === 'text/plain') {
            section.text = buf2String(arraybuf.slice(section.bodyStart, section.end));
        } else {
            const imgData = arraybuf.slice(section.bodyStart, section.end);
            section.file = new Blob([imgData], {
                type: section.header!['content-type'],
            });
            const fileNameMatching = /\bfilename="([^"]*)"/g.exec(section.header!['content-disposition']) || [];
            section.fileName = fileNameMatching[1] || '';
        }
        const matching = /\bname="([^"]*)"/g.exec(section.header!['content-disposition']) || [];
        section.name = matching[1] || '';

        delete section.headerStart;
        delete section.bodyStart;
        delete section.end;
    }

    return sections;
}

function multiparts(arraybuf: Uint8Array, boundary: string) {
    boundary = '--' + boundary;
    const parser = new Parser(arraybuf, boundary);

    let sections: Section[] = [];
    while (parser.skipPastNextBoundary()) {
        const header = parser.parseHeader();

        if (header !== null) {
            const headerLength = header.length;
            const headerParts = header.trim().split('\n');

            const headerObj: Record<string, string> = {};
            for (let i = 0; i !== headerParts.length; ++i) {
                const parts = headerParts[i].split(':');
                headerObj[parts[0].trim().toLowerCase()] = (parts[1] || '').trim();
            }

            sections.push({
                bodyStart: parser.i,
                header: headerObj,
                headerStart: parser.i - headerLength,
            });
        }
    }

    // add dummy section for end
    sections.push({
        headerStart: arraybuf.byteLength - boundary.length - 2, // 2 hyphens at end
    });
    for (let i = 0; i !== sections.length - 1; ++i) {
        sections[i].end = sections[i + 1].headerStart! - boundary.length;

        if (['\r', '\n'].includes(String.fromCharCode(arraybuf[sections[i].end!]))) {
            sections[i].end! -= 1;
        }
    }
    // remove dummy section
    sections.pop();

    sections = processSections(arraybuf, sections);

    return sections;
}

export interface ParsedSection {
    blob: Blob;
    fileName?: string;
}

export type ParseResult = Record<string, ParsedSection>;

export function parse(arraybuf: Uint8Array, boundary: string): ParseResult {
    return multiparts(arraybuf, boundary).reduce<ParseResult>((acc, section) => {
        acc[section.name!] = {
            blob: section.file!,
            fileName: section.fileName,
        };

        return acc;
    }, {});
}