export async function createBuildDirectory(buildDirectory: string, templateDirectory: string, assets: string[]) {

    // read directory
    const files = await readDir(templateDirectory);
    await Bluebird.all(files

        // ignore *.mustache templates
        .filter(file => path.extname(file) !== '.mustache')

        // copy recursive
        .map(file => copyAll(
            path.resolve(templateDirectory, file),
            path.resolve(buildDirectory, file),
        ))
    );

    // create assets directory
    await mkDir(path.resolve(buildDirectory, 'assets'));

    await Bluebird.all(assets
        .map(asset => copyAll(
            asset,
            path.resolve(buildDirectory, 'assets', path.basename(asset))
        ))
    );
}

    it('GET will not return the tribe if a player had that email but had it removed.', async function () {
        let tribe = {id: 'delete-me', name: 'tribe-from-endpoint-tests'};
        let playerId = monk.id();
        await Bluebird.all([
            host.post(path).send(tribe),
            host.post(path + '/players').send({
                _id: playerId,
                name: 'delete-me',
                tribe: 'delete-me',
                email: userEmail + '._temp'
            })
        ]);

        await authorizeUserForTribes([]);

        await host.post(path + '/players').send({
            _id: playerId,
            name: 'delete-me',
            tribe: 'delete-me',
            email: 'something else '
        });

        const response = await host.get(path)
            .expect(200)
            .expect('Content-Type', /json/);
        expect(clean(response.body)).toEqual(clean([]));

        await Bluebird.all([
            tribesCollection.remove({id: 'delete-me'}, false),
            playersCollection.remove({_id: playerId})
        ]);
    });

export function updatePhotos(photos: PhotoType[], update: Partial<PhotoType>) {
    let updatePhotoWorkPromise = null
    if (update.hasOwnProperty('flag')) {
        updatePhotoWorkPromise = Promise.all(photos.map(photo =>
            updatePhotoWork(
                photo,
                photoWork => {
                    if (update.flag) {
                        photoWork.flagged = true
                    } else {
                        delete photoWork.flagged
                    }
                })
        ))
    }

    const photoIds = photos.map(photo => photo.id)
    Promise.all([
        updatePhotoWorkPromise,
        updatePhotosInDb(photoIds, update)
    ])
    .then(() => {
        const changedPhotos = photos.map(photo => ({ ...photo, ...update } as PhotoType))
        store.dispatch(changePhotosAction(changedPhotos, update))
    })
    .catch(error => {
        // TODO: Show error in UI
        console.error('Updating photos failed', error)
    })
}

    getAll(keys: K[]): Promise<any[]> {
        var partitionService = this.client.getPartitionService();
        var partitionsToKeys: {[id: string]: any} = {};
        var key: K;
        for (var i in keys) {
            key = keys[i];
            var keyData = this.toData(key);
            var pId: number = partitionService.getPartitionId(keyData);
            if (!partitionsToKeys[pId]) {
                partitionsToKeys[pId] = [];
            }
            partitionsToKeys[pId].push(keyData);
        }

        var partitionPromises: Promise<[Data, Data][]>[] = [];
        for (var partition in partitionsToKeys) {
            partitionPromises.push(this.encodeInvokeOnPartition<[Data, Data][]>(
                MapGetAllCodec,
                Number(partition),
                partitionsToKeys[partition])
            );
        }
        var toObject = this.toObject.bind(this);
        var deserializeEntry = function(entry: [Data, Data]) {
            return [toObject(entry[0]), toObject(entry[1])];
        };
        return Promise.all(partitionPromises).then(function(serializedEntryArrayArray: [Data, Data][][]) {
            return Array.prototype.concat.apply([], serializedEntryArrayArray).map(deserializeEntry);
        });
    }

 /**
  * process `messages` with registered processes
  */
 process(files: string[], executeFile: (filePath: string) => Promise<TextlintResult>): Promise<TextlintResult[]> {
     const unExecutedResults: Array<Promise<TextlintResult>> = [];
     const resultPromises = files
         .filter(filePath => {
             const shouldExecute = this._backers.every(backer => {
                 return backer.shouldExecute({ filePath });
             });
             // add fake unExecutedResults for un-executed file.
             if (!shouldExecute) {
                 unExecutedResults.push(this._createFakeResult(filePath));
             }
             return shouldExecute;
         })
         .map(filePath => {
             return executeFile(filePath).then(result => {
                 this._backers.forEach(backer => {
                     backer.didExecute({ result });
                 });
                 return result;
             });
         })
         .concat(unExecutedResults);
     // wait all resolved, and call afterAll
     return Promise.all(resultPromises).then((results: (TextlintResult)[]) => {
         this._backers.forEach(backer => {
             backer.afterAll();
         });
         return results;
     });
 }

 .then(details => promise
     .all([
         writeFile(`${details.slidePath}/${details.slideName}.component.ts`, componentTemplate(details)),
         writeFile(`${details.slidePath}/${details.slideName}.component.html`, htmlTemplate(details)),
         writeFile(`${details.slidePath}/${details.slideName}.component.scss`, scssTemplate(details)),
     ])
     .then(() => details)

                    return new Promise((resolve, reject) => {
                        try {
                            if (fs.readFileSync(wifi.configFiles.hostapdConf.path).toString().indexOf('# wifi-setup config') === -1) {
                                Utils.backupFile(wifi.configFiles.hostapdConf.path);
                            }
                        } catch (e) {}

                        let getHostapdFile = new Promise((resolve, reject) => {
                            fs.readFile(`${__dirname}/hostapd.conf.fill`, (err, file) => {
                                if (err) {
                                    reject(err);
                                } else {
                                    resolve(file);
                                }
                            });
                        });
                        Promise.all([getHostapdFile, wifi.getDriver()]).then((results) => {
                            let file = results[0];
                            // let driver = results[1] || 'rtl871xdrv';
                            let driver = 'rtl871xdrv';

                            var hostapdConf = file.toString();
                            hostapdConf = Utils.replaceAll(hostapdConf, '{{SSID}}', SSID);
                            hostapdConf = Utils.replaceAll(hostapdConf, '{{password}}', password);
                            hostapdConf = Utils.replaceAll(hostapdConf, '{{driver}}', driver);
                            fs.writeFile(wifi.configFiles.hostapdConf.path, hostapdConf, (err) => {
                                if (err) {
                                    reject(err);
                                } else {
                                    resolve();
                                }
                            });
                        });
                    });

 .then(function() {
   console.log("THEN");
   return Promise.all([
     client.createReceiver('fhir_datasync_queue_dev', { auto_delete: true })
     //client.createSender('fhir_datasync_queue_dev')
   ]);
 })

export function refresh() {
    // set the history panel to false and remove the class that show the button history active when refresh
    $gitPanel.find(".git-history-toggle").removeClass("active").attr("title", Strings.TOOLTIP_SHOW_HISTORY);
    $gitPanel.find(".git-file-history").removeClass("active").attr("title", Strings.TOOLTIP_SHOW_FILE_HISTORY);

    if (gitPanelMode === "not-repo") {
        $tableContainer.empty();
        return Promise.resolve();
    }

    $tableContainer.find("#git-history-list").remove();
    $tableContainer.find(".git-edited-list").show();

    const p1 = Git.status().catch((err) => {
        // this is an expected "error"
        if (ErrorHandler.contains(err, "Not a git repository")) {
            return;
        }
        throw err;
    });

    const p2 = refreshCommitCounts();

    // Clone button
    $gitPanel.find(".git-clone").prop("disabled", false);

    // FUTURE: who listens for this?
    return Promise.all([p1, p2]);
}

    it('when there are multiple connections, gives you the total connection count for the current tribe', function (done) {
        Bluebird.all([
            this.promiseWebsocket(tribeA.id),
            this.promiseWebsocket(tribeB.id),
        ])
            .then(bundles => Bluebird.all(bundles.concat([
                this.promiseWebsocket(tribeA.id),
                this.promiseWebsocket(tribeB.id),
                this.promiseWebsocket(tribeB.id),
            ])))
            .then(bundles => Bluebird.all(bundles.concat([
                this.promiseWebsocket(tribeC.id),
                this.promiseWebsocket(tribeB.id),
            ])))
            .then(bundles => {
                const lastTribeAConnection = bundles[2];
                expect(lastTribeAConnection.messages).toEqual([makeConnectionMessage(2)]);

                const lastTribeBConnection = bundles[bundles.length - 1];
                expect(lastTribeBConnection.messages).toEqual([makeConnectionMessage(4)]);

                const lastTribeCConnection = bundles[5];
                expect(lastTribeCConnection.messages).toEqual([makeConnectionMessage(1)]);

                return bundles;
            })
            .then(closeAllSockets())
            .then(done, done.fail);
    });