/**
 * Copyright (c) Microsoft Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import fs from 'fs';
import * as yazl from 'yazl';
import { ManualPromise } from '@isomorphic/manualPromise';
export class SerializedFS {
    _buffers = new Map(); // Should never be accessed from within appendOperation.
    _error;
    _operations = [];
    _operationsDone;
    constructor() {
        this._operationsDone = new ManualPromise();
        this._operationsDone.resolve(); // No operations scheduled yet.
    }
    mkdir(dir) {
        this._appendOperation({ op: 'mkdir', dir });
    }
    writeFile(file, content, skipIfExists) {
        this._buffers.delete(file); // No need to flush the buffer since we'll overwrite anyway.
        this._appendOperation({ op: 'writeFile', file, content, skipIfExists });
    }
    appendFile(file, text, flush) {
        if (!this._buffers.has(file))
            this._buffers.set(file, []);
        this._buffers.get(file).push(text);
        if (flush)
            this._flushFile(file);
    }
    _flushFile(file) {
        const buffer = this._buffers.get(file);
        if (buffer === undefined)
            return;
        const content = buffer.join('');
        this._buffers.delete(file);
        this._appendOperation({ op: 'appendFile', file, content });
    }
    copyFile(from, to) {
        this._flushFile(from);
        this._buffers.delete(to); // No need to flush the buffer since we'll overwrite anyway.
        this._appendOperation({ op: 'copyFile', from, to });
    }
    async syncAndGetError() {
        for (const file of this._buffers.keys())
            this._flushFile(file);
        await this._operationsDone;
        return this._error;
    }
    zip(entries, zipFileName) {
        for (const file of this._buffers.keys())
            this._flushFile(file);
        // Chain the export operation against write operations,
        // so that files do not change during the export.
        this._appendOperation({ op: 'zip', entries, zipFileName });
    }
    // This method serializes all writes to the trace.
    _appendOperation(op) {
        const last = this._operations[this._operations.length - 1];
        if (last?.op === 'appendFile' && op.op === 'appendFile' && last.file === op.file) {
            // Merge pending appendFile operations for performance.
            last.content += op.content;
            return;
        }
        this._operations.push(op);
        if (this._operationsDone.isDone())
            this._performOperations();
    }
    async _performOperations() {
        this._operationsDone = new ManualPromise();
        while (this._operations.length) {
            const op = this._operations.shift();
            // Ignore all operations after the first error.
            if (this._error)
                continue;
            try {
                await this._performOperation(op);
            }
            catch (e) {
                this._error = e;
            }
        }
        this._operationsDone.resolve();
    }
    async _performOperation(op) {
        switch (op.op) {
            case 'mkdir': {
                await fs.promises.mkdir(op.dir, { recursive: true });
                return;
            }
            case 'writeFile': {
                // Note: 'wx' flag only writes when the file does not exist.
                // See https://nodejs.org/api/fs.html#file-system-flags.
                // This way tracing never have to write the same resource twice.
                if (op.skipIfExists)
                    await fs.promises.writeFile(op.file, op.content, { flag: 'wx' }).catch(() => { });
                else
                    await fs.promises.writeFile(op.file, op.content);
                return;
            }
            case 'copyFile': {
                await fs.promises.copyFile(op.from, op.to);
                return;
            }
            case 'appendFile': {
                await fs.promises.appendFile(op.file, op.content);
                return;
            }
            case 'zip': {
                const zipFile = new yazl.ZipFile();
                const result = new ManualPromise();
                zipFile.on('error', error => result.reject(error));
                for (const entry of op.entries)
                    zipFile.addFile(entry.value, entry.name);
                zipFile.end();
                zipFile.outputStream
                    .pipe(fs.createWriteStream(op.zipFileName))
                    .on('close', () => result.resolve())
                    .on('error', error => result.reject(error));
                await result;
                return;
            }
        }
    }
}
//# sourceMappingURL=serializedFS.js.map