discogs.coffee

querystring = require 'querystring'
request     = require 'request'
zlib        = require 'zlib'
discogs     = require '../package.json'

exports = module.exports = (format) ->
  format = null if format is 'json' # JSON is the default and the API doesn't work with f=json

  getUrl = (url) ->

    url = "http://api.discogs.com/#{url}" if url.substr(0, 7) isnt 'http://'
    sep = if "?" in url then "&" else "?"

    url += "#{sep}f=#{format}" if format
    url

  discogsRequest = (url, next) ->

    parseResponse = (err, res, body) ->

      if err then next err
      else if ~res.headers['content-type']?.indexOf('json') or not format
        try
          next null, JSON.parse body
        catch e
          next e
      else
        next null, body

    request
      uri: getUrl url
      headers:
        'accept-encoding': 'gzip'
        'user-agent': "#{discogs.name}/#{discogs.version} +#{discogs.homepage}"
      encoding: null
      (error, res, body) ->
        if not error and 200 <= res.statusCode < 400
          if ~res.headers['content-encoding']?.indexOf 'gzip'
            zlib.gunzip body, (err, body) ->
              parseResponse err, res, body
          else
            parseResponse error, res, body.toString 'utf8'
        else
          next error

  responseHandler = (type, next) -> (err, res) ->

      if err then next err
      else next null, res?.resp?[type]

  get: (url, next) ->
    discogsRequest url, next

  master: (id, next) ->
    discogsRequest 'master/' + id,
      responseHandler('master', next)

  release: (id, next) ->
    discogsRequest 'release/' + id,
      responseHandler('release', next)

  artist: (name, next) ->
    discogsRequest 'artist/' + name,
      responseHandler('artist', next)

  label: (name, next) ->
    discogsRequest 'label/' + name,
      responseHandler('label', next)

  search: (query, type, next) ->
    if type instanceof Function
      next = type
      type = 'all'
    discogsRequest 'search?' + querystring.stringify(type: type, q: query),
      responseHandler('search', next)

  lookup: (query, next) ->
    @search query, "releases", (err, res) =>
      return next err if err

      results = res?.searchresults?.results
      return next() unless results

      masters = (result for result in results when result.type is "master")

      results = masters if masters.length

      matches = (result for result in results when result.title.toLowerCase() is query.toLowerCase())

      results = matches if matches.length

      release = results[0]
      id = release.uri.split("/").pop()

      @[release.type] id, (err, res) =>
        if "master_id" of res

          @master res.master_id, (err, master) =>
            if "main_release" of master
              @release master.main_release, next
            else
              next null, master
        else if "main_release" of res

          @release res.main_release, next
        else

          next null, res