export function show() {
    defer = Promise.defer();

    const templateArgs = {
        modeLabel: Strings.CLONE_REPOSITORY,
        Strings
    };

    const compiledTemplate = Mustache.render(template, templateArgs, {
        credentials: credentialsTemplate
    });
    const dialog = Dialogs.showModalDialogUsingTemplate(compiledTemplate);
    const $dialog = dialog.getElement();

    $cloneInput = $dialog.find("#git-clone-url");

    _attachEvents($dialog);

    dialog.done((buttonId) => {
        if (buttonId === "ok") {
            const cloneConfig = {
                remote: "origin",
                remoteUrl: $cloneInput.val()
            };
            RemoteCommon.collectValues(cloneConfig, $dialog);
            defer.resolve(cloneConfig);
        } else {
            defer.reject();
        }
    });

    return defer.promise;
}

export function show(_pullConfig) {
    defer = Promise.defer();
    pullConfig = _pullConfig;
    pullConfig.pull = true;
    RemoteCommon.collectInfo(pullConfig).then(_show);
    return defer.promise;
}

export function existsAsync(path: string): Promise<boolean>{
    var deferral = Promise.defer();
    fs.exists(path, (res) => {
        deferral.resolve(res);
    });
    return deferral.promise;
}

 function postString(msg): PromiseLike<Typehinted> {
   const p = Promise.defer<Typehinted>();
   const wireMsg = `{"req": ${msg}, "callId": ${ensimeMessageCounter}}`
   callbackMap[ensimeMessageCounter++] = p
   log.debug("outgoing: " + wireMsg)
   netClient.send(wireMsg)
   return p.promise;
 }

 /**
  * Listen the restify server.
  * @override
  * @returns {Promise<void>}
  */
 public listen() {
   var deferred = Promise.defer<void>();
   this.adaptee.listen(this.options.port, (err) => {
     if (err) return deferred.reject(err);
     deferred.resolve();
   });
   return deferred.promise;
 }

function backoff(idx: number) {
    let timeout = BACKOFF[idx];
    let dfd = P.defer();
    log.info("Retrying request after:", timeout);
    setTimeout(() => {
        dfd.resolve(timeout);
    }, timeout);
    return dfd.promise;
}

export function readDirAsync(path: string): Promise<string[]>{
    var deferral = Promise.defer();
    fs.readdir(path, (err, res) => {
        if(err){
            deferral.reject(err);
        } else {
            deferral.resolve(res);
        }
    });
    return deferral.promise;
}

const withTempFile = (filePath: string, bufferText: string) : PromiseLike<string> => {
    const tempFilePath = getTempPath(filePath);
    const p = Promise.defer<string>();
    fs.outputFile(tempFilePath, bufferText, (err) => {
        if (err)
            p.reject("error with file");
        else 
            p.resolve(tempFilePath);
    });
    return p.promise; 
} 

export function readAsync(path: string): Promise<string>{
    var deferral = Promise.defer();
    fs.readFile(path, "utf-8", (err, res) => {
        if(err){
            deferral.reject(err);
        } else {
            deferral.resolve(res);
        }
    });
    return deferral.promise;
}

 }).catch((err) => {
     if (ErrorHandler.contains(err, "Please tell me who you are")) {
         const defer = Promise.defer();
         EventEmitter.emit(Events.GIT_CHANGE_USERNAME, null, () => {
             EventEmitter.emit(Events.GIT_CHANGE_EMAIL, null, () => {
                 defer.resolve();
             });
         });
         return defer.promise;
     }
     return ErrorHandler.showError(err, "Git Commit failed");
 }).finally(() => {