// # DosFS
// API for working with file system of dosbox

import CacheNoop from "./js-dos-cache-noop";
import { DosModule } from "./js-dos-module";
import { Xhr } from "./js-dos-xhr";

// ### DosArchiveSource
export interface DosArchiveSource {
    // source (archive) to download and extract via `extractAll`

    // **url** where archive is located
    url: string;

    // **mountPoint**
    mountPoint: string;
    // is a path to mount archive contents. There are two types of mountPoints:
    //
    // * path '/' which is a MEMFS that is live only in one ssesion.
    // It means that after restart all progress will be erased.
    //
    // * any other path (e.g. '/game'). This path will be stored across sessions in indexed db. It means
    // that progress will be there after browser restart.
    //
    // In other words, you can use path '/' to store temporal data, but others use to store
    // content that need to be persisten.
    //
    // **NOTE**: because content of folder is stored in indexed db original archive is downloaded
    // and extracted only once to avoid rewriting stored content! And you can't store different
    // content (from different archives) into one path.

    // **type** currently we support only zip archives
    type?: "zip";
}

// ## DosFS
export class DosFS {
    private dos: DosModule;
    private em: any; // typeof Module;
    private fs: any;
    private syncingPromise: Promise<void> | null = null;
    private lastSyncTime = 0;

    constructor(dos: DosModule) {
        this.dos = dos;
        this.em = dos as any;
        this.fs = (dos as any).FS;

        // Sync fs to indexed db periodically
        this.dos.registerTickListener(() => {
            if (Date.now() - this.lastSyncTime < 5000) {
                return;
            }
            this.lastSyncTime = Date.now();
            this.syncFs();
        });
        this.dos.registerPauseListener(() => this.syncFs());
        this.dos.registerTerminateListener(() => this.syncFs());
    }

    public chdir(path: string) {
        this.fs.chdir(path);
    }

    // ### extract
    public extract(url: string, mountPoint: string = "/", type: "zip" = "zip"): Promise<void> {
        // simplified version of extractAll, works only for one archive. It calls extractAll inside.
        return this.extractAll([{ url, mountPoint, type }]);
    }

    // ### extractAll
    public extractAll(sources: DosArchiveSource[]): Promise<void> {
        // tslint:disable-next-line
        // download given [`sources`](https://js-dos.com/6.22/docs/api/generate.html?page=js-dos-fs#dosfs-dosarchivesource)
        // and extract them to mountPoint's.
        //
        // this method will return `Promise<void>`, that will be resolved
        // on success with empty object or rejected
        const extractArchiveInCwd = (url: string, path: string, type: "zip") => {
            return new Promise<void>((resolve, reject) => {
                if (type !== "zip") {
                    reject("Only ZIP archive is supported");
                    return;
                }

                new Xhr(url, {
                    cache: new CacheNoop(),
                    responseType: "arraybuffer",
                    fail: (msg) => reject(msg),
                    progress: (total, loaded) => {
                        if (this.dos.onprogress !== undefined) {
                            this.dos.onprogress("Downloading " + url, total, loaded);
                        }
                    },
                    success: (data: ArrayBuffer) => {
                        this.chdir(path);

                        const bytes = new Uint8Array(data);
                        const buffer = this.em._malloc(bytes.length);
                        this.em.HEAPU8.set(bytes, buffer);
                        const retcode = this.em._extract_zip(buffer, bytes.length);
                        this.em._free(buffer);

                        if (retcode === 0) {
                            this.writeOk(path);
                            resolve();
                        } else {
                            reject("Can't extract zip, retcode " + retcode + ", see more info in logs");
                        }
                    },
                });
            });
        };

        const prepareMountFunction = (source: DosArchiveSource) => {
            const mountPoint = this.normalizePath(source.mountPoint);
            const type = source.type || "zip";
            const isRoot = mountPoint === "/" || mountPoint.length === 0;

            const parts = mountPoint.split("/");
            this.createPath(parts, 0, parts.length);

            const mountFn = () => {
                if (isRoot || !this.readOk(mountPoint)) {
                    if (!isRoot) {
                        this.dos.warn("Indexed db does not contains '" + mountPoint + "' rewriting...");
                    }
                    return extractArchiveInCwd(source.url, mountPoint, type);
                }
                return Promise.resolve();
            };

            if (!isRoot) {
                this.fs.mount(this.fs.filesystems.IDBFS, {}, mountPoint);
            }

            return mountFn;
        };

        return new Promise<void>((resolve, reject) => {
            if (this.lastSyncTime > 0) {
                reject("Can't create persistent mount point, after syncing process starts");
                return;
            }

            const mountFunctions: Array<() => Promise<void>> = [];
            for (const source of sources) {
                mountFunctions.push(prepareMountFunction(source));
            }

            this.fs.syncfs(true, (err: any) => {
                if (err) {
                    this.dos.error("Can't restore FS from indexed db, cause: " + err);
                }

                const promises: Array<Promise<void>> = [];
                for (const mountFn of mountFunctions) {
                    promises.push(mountFn());
                }

                Promise.all(promises)
                    .then(() => {
                        this.syncFs().then(resolve).catch(reject);
                    })
                    .catch(reject);
            });
        });
    }

    // ### createFile
    public createFile(file: string, body: ArrayBuffer | Uint8Array | string) {
        // [synchronous] allow to create file in FS, you can pass absolute path.
        // All directories will be created
        //
        // body can be string or ArrayBuffer or Uint8Array

        if (body instanceof ArrayBuffer) {
            body = new Uint8Array(body);
        }

        // windows style path are also valid, but **drive letter is ignored**
        // if you pass only filename, then file will be writed in root "/" directory
        file = file.replace(new RegExp("^[a-zA-z]+:"), "").replace(new RegExp("\\\\", "g"), "/");
        const parts = file.split("/");

        if (parts.length === 0) {
            if (this.dos.onerror !== undefined) {
                this.dos.onerror("Can't create file '" + file + "', because it's not valid file path");
            }
            return;
        }

        const filename = parts[parts.length - 1].trim();

        if (filename.length === 0) {
            if (this.dos.onerror !== undefined) {
                this.dos.onerror("Can't create file '" + file + "', because file name is empty");
            }
            return;
        }

        /* i < parts.length - 1, because last part is file name */
        const path = this.createPath(parts, 0, parts.length - 1);
        this.fs.createDataFile(path, filename, body, true, true, true);
    }

    public writeFsToFile(filename: string, fsPattern: RegExp, mountName: string) {

        this.fs.syncfs(false, (err: any) => {
            if (!err) {
                window.indexedDB.open(mountName).onsuccess = (e: any) => {

                    const db = e.target.result;
                    const content: any = {};

                    db.transaction(["FILE_DATA"], "readonly")
                        .objectStore("FILE_DATA")
                        .openCursor().onsuccess = (e: any) => {

                            const cursor = e.target.result;

                            if (cursor) {

                                if (!fsPattern || fsPattern.test(cursor.key)) {
                                    const value = cursor.value;
                                    value.contents = DosFS.toBase64(value.contents);
                                    const key = cursor.key;
                                    content[key] = value;
                                }

                                cursor.continue();
                            } else {
                                DosFS.saveToFile(
                                    filename,
                                    JSON.stringify(content));
                            }
                        };
                };
            }
        });
    }

    public readFsFromFile(file: Blob) {
        if (!file) {
            return;
        }

        const reader = new FileReader();

        reader.onload = (e: any) => {

            if (!e.target) {
                return;
            }

            const content: any = e.target.result;
            const entries = JSON.parse(content);

            for (const key of Object.keys(entries)) {
                const value = entries[key];
                const contents = DosFS.fromBase64(value.contents);

                if (this.fs.analyzePath(key).exists) {
                    this.fs.unlink(key);
                }

                this.createFile(key, contents);
            }
        };

        reader.readAsText(file);
    }

    private static toBase64(bytes: Uint8Array): string {
        let binary = "";
        const len = bytes.byteLength;
        for (let i = 0; i < len; i++) {
            binary += String.fromCharCode(bytes[ i ]);
        }
        return window.btoa( binary );
    }

    private static fromBase64(base64: string): Uint8Array {
        const binaryString =  window.atob(base64);
        const len = binaryString.length;
        const bytes = new Uint8Array( len );
        for (let i = 0; i < len; i++)        {
            bytes[i] = binaryString.charCodeAt(i);
        }
        return bytes;
    }

    private static saveToFile(filename: string, data: string) {
        const blob = new Blob([data], {type: "text/csv"});
        const elem = window.document.createElement("a");
        elem.href = window.URL.createObjectURL(blob);
        elem.download = filename;
        document.body.appendChild(elem);
        elem.click();
        document.body.removeChild(elem);
    }

    private createPath(parts: string[], begin: number, end: number) {
        let path = "";
        for (let i = begin; i < end; ++i) {
            const part = parts[i].trim();
            if (part.length === 0) {
                continue;
            }

            this.fs.createPath(path, part, true, true);
            path = path + "/" + part;
        }

        return path;
    }

    private syncFs() {
        if (this.syncingPromise) {
            return this.syncingPromise;
        }

        this.syncingPromise = new Promise<void>((resolve, reject) => {
            // @ts-ignore the unusued local for startedAt not being read
            const startedAt = Date.now();
            this.fs.syncfs(false, (err: any) => {
                if (err) {
                    this.dos.error("Can't sync FS to indexed db, cause: " + err);
                    reject(err);
                }
                this.syncingPromise = null;
                this.lastSyncTime = Date.now();
                resolve();
            });
        });

        return this.syncingPromise;
    }

    private normalizePath(path: string) {
        if (path.length === 0 || path[0] !== "/") {
            path = "/" + path;
        }

        if (path.length > 1 && path.endsWith("/")) {
            path = path.substr(0, path.length - 1);
        }

        return path;
    }

    private readOk(path: string) {
        try {
            const readed = this.fs.readFile(path + "/state.fs");
            return readed[0] === 79 && readed[1] === 70;
        } catch {
            return false;
        }
    }

    private writeOk(path: string) {
        this.createFile(path + "/state.fs", new Uint8Array([79, 70])); // Ok
    }

}