import mimeTypes from 'mime-types';
import Proto from 'uberproto';
import { parseDataURI } from 'dauria';
import { bufferToHash, fromBuffer } from '../utils/buffer';

export default class Service {
  constructor(options) {
    if (typeof options === 'undefined') {
      throw new Error('blob-service: constructor `options` must be provided');
    }

    if (typeof options.Model === 'undefined') {
      throw new Error('blob-service: constructor `options.Model` must be provided');
    }

    this.Model = options.Model;
    this.id = options.id || 'id';
  }

  extend(obj) {
    return Proto.extend(obj, this);
  }

  get(id, params) {
    return new Promise((resolve, reject) => {
      const { response } = params;
      if (typeof response === 'undefined') {
        throw new Error('blob-service: no response object attached to params. Make sure to use middleware');
      }

      const readStream = this.Model.createReadStream({ key: id });

      readStream.on('error', reject);
      readStream.on('open', () => {
        readStream.pipe(response);
      });
      readStream.on('end', () => {
        resolve({
          [ this.id ]: id
        });
      });
    });
  }

  create(body) {
    return new Promise((resolve, reject) => {
      const { uri } = body;
      const { buffer, MIME: contentType } = parseDataURI(uri);
      const hash = bufferToHash(buffer);
      const extension = mimeTypes.extension(contentType);
      const id = `${ hash }.${ extension }`;

      const writeStream = this.Model.createWriteStream({ key: id });

      writeStream.on('error', reject);
      fromBuffer(buffer).pipe(writeStream);
      writeStream.on('finish', () => {
        resolve({
          [ this.id ]: id
        });
      });
    });
  }

  remove(id) {
    return new Promise((resolve, reject) => {
      this.Model.remove({ key: id }, error => {
        if (typeof error === 'undefined') {
          resolve(id);
        } else {
          reject(error);
        }
      });
    });
  }
}