// Returns the S3 url or local file path
  async returnPdf(options?: PdfOptions): Promise<string> {
    const data = await pdf(this.client, options)

    // check if S3 configured
    if (
      process.env['CHROMELESS_S3_BUCKET_NAME'] &&
      process.env['CHROMELESS_S3_BUCKET_URL']
    ) {
      const s3Path = `${cuid()}.pdf`
      const s3 = new AWS.S3()
      await s3
        .putObject({
          Bucket: process.env['CHROMELESS_S3_BUCKET_NAME'],
          Key: s3Path,
          ContentType: 'application/pdf',
          ACL: 'public-read',
          Body: new Buffer(data, 'base64'),
        })
        .promise()

      return `https://${process.env['CHROMELESS_S3_BUCKET_URL']}/${s3Path}`
    } else {
      // write to `${os.tmpdir()}` instead
      const filePath = path.join(os.tmpdir(), `${cuid()}.pdf`)
      fs.writeFileSync(filePath, Buffer.from(data, 'base64'))

      return filePath
    }
  }

  // Returns the S3 url or local file path
  async returnScreenshot(): Promise<string> {
    const data = await screenshot(this.client)

    // check if S3 configured
    if (process.env['CHROMELESS_S3_BUCKET_NAME'] && process.env['CHROMELESS_S3_BUCKET_URL']) {
      const s3Path = `${cuid()}.png`
      const s3 = new AWS.S3()
      await s3.putObject({
        Bucket: process.env['CHROMELESS_S3_BUCKET_NAME'],
        Key: s3Path,
        ContentType: 'image/png',
        ACL: 'public-read',
        Body: new Buffer(data, 'base64'),
      }).promise()

      return `https://${process.env['CHROMELESS_S3_BUCKET_URL']}/${s3Path}`
    }

    // write to `/tmp` instead
    else {
      const filePath = `/tmp/${cuid()}.png`
      fs.writeFileSync(filePath, Buffer.from(data, 'base64'))

      return filePath
    }
  }

 return new Promise((resolve, reject) => {
   const s3 = new AWS.S3({
     accessKeyId, secretAccessKey,
     region: region || 'ap-northeast-1',
     apiVersion: '2006-03-01'
   });
   return s3.getObject({ Bucket: bucket, Key: key }, (error, data) => {
     if (error) {
       reject(error);
     } else {
       resolve(JSON.parse(data.Body));
     }
   });
 });

 async deploy(args) {
   this._s3 = new (this._getAWS(this.resources)).S3();
   let bucket = this.resources.target;
   let source = path.resolve(this.resources.source);
   this.bucket = bucket;
   this.source = source;
   console.log("Deploy", source, "on S3 Bucket", bucket);
   await this.createBucket(bucket);
   let files = Finder.from(source).findFiles();
   // Should implement multithread here - cleaning too
   for (let i in files) {
     let file = files[i];
     let key = path.relative(source, file);
     // Need to have mimetype to serve the content correctly
     let mimetype = mime.contentType(path.extname(file));
     await this._s3
       .putObject({
         Bucket: bucket,
         Body: fs.createReadStream(file),
         Key: key,
         ContentType: mimetype
       })
       .promise();
     console.log("Uploaded", file, "to", key, "(" + mimetype + ")");
   }
   if (!this.resources.staticWebsite) {
     return;
   }
   await this._createWebsite();
 }

 runS3Script(cb: {(err: Error | null, res: any)}) {
   this.s3.getObject({Bucket: this.bucket!, Key: this.scriptUrl!}, (err, resp) => {
     if (err) return cb(err, null)
     const script = resp.Body.toString('utf8')
     this.runScript(script, cb)
   })
 }

  public storeImage(buffer: Buffer): Promise<string> {
    const key = this.randomPath()
    const region = process.env.SLACKBOT_S3_BUCKET_REGION
    const domain = region && (region !== "us-east-1") ?
      `s3-${process.env.SLACKBOT_S3_BUCKET_REGION}.amazonaws.com`
    :
      "s3.amazonaws.com"

    const params = {
      ACL: "public-read",
      Body: buffer,
      Bucket: process.env.SLACKBOT_S3_BUCKET,
      ContentType: "image/png",
      Key: key,
    }

    const s3 = new AWS.S3({
      endpoint: new AWS.Endpoint(domain) as any,
    })

    return new Promise<string>((resolve, reject) => {
      s3.putObject(params, (err, data) => {
        if (err) {
          reject(`S3 Error: ${err.message}`)
        } else {
          resolve(`https://${domain}/${params.Bucket}/${key}`)
        }
      })
    })

  }

 async saveToS3(id, manifest) {
   const s3 = new S3();
   return new Promise((resolve, reject) => {
     s3.upload({ Body: JSON.stringify(manifest), Bucket: this.registryBucket, Key: id}, (err, res) => {
       if (err) return reject(err);
       resolve(res);
     })
   });
 }

 /**
  * Fetch a public url for the resource.
  */
 private getPublicUrl(key: string) {
   return this.s3.getSignedUrl('getObject', {
     Bucket: getConfig().BUCKET_NAME,
     Key: key,
     Expires: 24 * 60 * 30,
   });
 }

 return new Promise((resolve, reject) => {
   s3.getObject({ Bucket, Key })
     .on("httpDone", x => {
       resolve(JSON.parse(x.httpResponse.body.toString()));
     })
     .send();
 });

 return new Promise((ok, fail) => {
   s3.putObject(args, (err, data) => {
     if (err) {
       return fail(err);
     }
     ok();
   });
 });