import fetch from 'node-fetch';

let content_type = "application/vnd.collection+json";

class HttpImplementation {

  // http_callback is used by each of the verb-methods below.
  // It should call `done` with (error_string_or_null, body_as_text,
  // response_headers)
  //
  http_callback(response, done) {
    if(response.status < 400) {
      // strangely, response.text() returns a promise...
      response.text().then((actual_response) => {
        done(null, actual_response, response.headers)
      })
    }
    else { done(response.status); }
  }

  get(href, options, done) {
    fetch(href).then((response) => {this.http_callback(response, done)}).
      catch(error => done(error));
  };

  post(href, options, done) {
    http_options = Object.assign({}, options,
        {
             method: "POST",        body: JSON.stringify(options.body),
            headers: options.headers,
           redirect: "follow",      mode: "CORS",
        credentials: "same-origin", referrer: "client",
        })

    return(fetch(href, http_options).then(this.http_callback, done));
  };

  put(href, options, done) {
    http_options = Object.assign({}, options,
      {
           method: "PUT",        body: JSON.stringify(options.body),
          headers: headers,
         redirect: "follow",      mode: "CORS",
      credentials: "same-origin", referrer: "client",
      })

    return(fetch(href, http_options).then(this.http_callback, done));
  }

  delete(href, options, done){
    http_options = Object.assign({}, options,
        {
             method: "DELETE",        body: JSON.stringify(options.body),
            headers: headers,
           redirect: "follow",      mode: "CORS",
        credentials: "same-origin", referrer: "client",
        })

    return(fetch(href, http_options).then(http_callback, done));
  };
}

class InterfaceLayer {
  constructor( network_layer )
  {
    if( network_layer == null || network_layer == undefined )
    { this.source = new HttpImplementation(); }
    else
    { this.source = network_layer ; }
  }

  get(href, options, done) {
    if(!options.headers) { options.headers = {} }
    options.headers["accept"] = content_type;

    this.source.get(href, options, function(error, collection, headers) {
      // the previous implementation of this was async, so
      // it might bear reworking once figured out
      // seems like you could add a layer that would try each one
      // and, on failure, try the next.

      if( error || collection )
      {
        // if a collection is returned, the source should handle caching
        // though in the original code...
        // https://github.com/collection-json/collection-json.js/blob/master/lib/http.coffee#L49
        return(done(error, collection, headers));
      }
      else
      {
        return(false);
      }
    })
  }

  post(href, options, done) {
    if (options == null) { options = {}; }
    if (!options.headers) { options.headers = {}; }

    options.headers = Object.assign({}, options.headers, {
      "accept": content_type,
      "content-type": content_type,
      "Content-Type": "application/collection+json; charset=utf-8"
    })

    this.source.post(href, options, function(error, collection, headers)
    {
      if( error || collection )
      {
        // if a collection is returned, the source should handle caching
        // though in the original code...
        // https://github.com/collection-json/collection-json.js/blob/master/lib/http.coffee#L49
        return(done(error, collection, headers));
      }
      else
      {
        return(false);
      }
    })
  }

  put(href, options, done) {
    if (options == null) { options = {}; }
    if (!options.headers) { options.headers = {}; }

    options.headers = Object.assign({}, options.headers, {
      "accept": content_type,
      "content-type": content_type,
      "Content-Type": "application/collection+json; charset=utf-8"
    })

    this.source.put(href, options, function(error, collection, headers)
    {
      if( error || collection )
      {
        // if a collection is returned, the source should handle caching
        // though in the original code...
        // https://github.com/collection-json/collection-json.js/blob/master/lib/http.coffee#L49
        return(done(error, collection, headers));
      }
      else
      {
        return(false);
      }
    })
  }

  delete(href, options, done) {
    if (options == null) { options = {}; }
    if (!options.headers) { options.headers = {}; }

    options.headers = Object.assign({}, options.headers, {
      "accept": content_type,
      "content-type": content_type,
      "Content-Type": "application/collection+json; charset=utf-8"
    })

    this.source.delete(href, options, function(error, collection, headers)
    {
      if( error || collection )
      {
        // if a collection is returned, the source should handle caching
        // though in the original code...
        // https://github.com/collection-json/collection-json.js/blob/master/lib/http.coffee#L49
        return(done(error, collection, headers));
      }
      else
      {
        return(false);
      }
    })
  }
}

export default (new InterfaceLayer())

import Client from '../src/client.js'

describe("LIVE test from ACTUAL API", () => {
  test("it gets an error when calling an invalid path", () => {
    new Client('http://todo-collection-json.herokuapp.com/invalid',
      (error, collection) => {
        expect(error).toBe(404);
        expect(collection).toBeUndefined();
      });
  })

  test('it works with a real-life-ish example', () => {
    expect.assertions();

    new Client('http://todo-collection-json.herokuapp.com/collection/tasks/',
      (error, collection) => {
        expect(collection).not.toBeDefined();
        console.log(collection);
        expect(error).toBeNull();
      });
  })
})

module.exports = defaults =
  _get: (href, options, done=()->)->
    done new Error "'GET' not implemented"

  _post: (href, options, done=()->)->
    done new Error "'POST' not implemented"

  _put: (href, options, done=()->)->
    done new Error "'PUT' not implemented"

  _del: (href, options, done=()->)->
    done new Error "'DELETE' not implemented"

  cache:
    # This is a fake cache. You should probably add a real one...
    put: (key, value, time, done=()->)->
      if typeof time is 'function'
        done = time
        time = null
      done()
    del: (key, done=()->)->
      done()
    clear: (done=()->)->
      done()
    get: (key, done=()->)->
      done()
    size: (done=()->)->
      done 0
    memsize: (done=()->)->
      done 0
    debug: ()->
      true

module.exports["content-type"] = "application/vnd.collection+json"

module.exports.get = (href, options, done)->
  defaults.cache.get href, (error, collection)->
    # Give them the cached stuff if we have it
    return done error, collection if error or collection

    options.headers ||= {}
    options.headers["accept"] = module.exports["content-type"]

    module.exports.setOptions href, options

    defaults._get href, options, (error, collection, headers)->
      return done error if error
      performCache collection, headers
      done error, collection

module.exports.post = (href, options={}, done)->

  options.headers ||= {}
  options.headers["accept"] = module.exports["content-type"]
  options.headers["content-type"] = module.exports["content-type"]

  module.exports.setOptions href, options

  defaults._post href, options, (error, collection, headers)->
    # Do we cache this?
    done error, collection

# Should be overridden by the client
module.exports.setOptions = (href, options)->

performCache = (collection, headers)->
  # Expires
  # expires = response.headers.expires
  # # TODO convert to time-from-now
  # # Cache-Control
  # # TODO implement
  # defaults.cache.put response.request.href, response.body, new Date(expires).getTime() if expires


//=====================================================================
// in another file, lib/index.coffee...
//=====================================================================

request = require "request"
http = require "./http"

http._get = (href, options, done)->
  options.url = href
  request options, (error, response, body)->
    done error, body, response?.headers

http._post = (href, options, done)->
  options.url = href
  options.body = JSON.stringify options.body
  options.method = "POST"
  request options, (error, response, body)->
    done error, body, response?.headers

http._put = (href, options, done)->
  options.url = href
  options.body = JSON.stringify options.body
  request.put options, (error, response)->
    done error, response

http._del = (href, options, done)->
  options.url = href
  request.del options, (error, response)->
    done error, response

module.exports = require "./client"