class HelpScout

# File lib/help_scout.rb, line 53
def initialize(api_key, api_secret, token_storage = TokenStorage::Memory.new)
  @api_key = api_key
  @api_secret = api_secret
  @token_storage = token_storage
end

# File lib/help_scout.rb, line 67
def create_conversation(data)
  # required_fields = ["subject", "type", "mailboxId", "status", "customer", "threads"]

  post("conversations", { body: data })

  last_response.headers["Resource-ID"]
end

# File lib/help_scout.rb, line 283
def create_customer_email(customer_id, data)
  post("customers/#{customer_id}/emails", { body: data })
end

# File lib/help_scout.rb, line 269
def create_customer_phone(customer_id, data)
  post("customers/#{customer_id}/phones", { body: data })
end

# File lib/help_scout.rb, line 198
def create_note(conversation_id:, text:, user: nil, imported: false)
  data = {
    text: text,
    user: user,
    imported: imported,
  }
  post("conversations/#{conversation_id}/notes", body: data)

  last_response.code == HTTP_CREATED
end

# File lib/help_scout.rb, line 212
def create_phone(conversation_id:, text:, customer:, imported: false)
  # Note, hs does not list user as an accepted type
  # https://developer.helpscout.com/mailbox-api/endpoints/conversations/threads/phone/
  data = {
    text: text,
    customer: {
      id: customer
    },
    imported: imported,
  }
  post("conversations/#{conversation_id}/phones", body: data)

  last_response.code == HTTP_CREATED
end

# File lib/help_scout.rb, line 230
def create_reply(conversation_id:, text:, customer:, user: nil, imported: false)
  data = {
    text: text,
    user: user,
    customer: {
      id: customer
    },
    imported: imported,
  }
  post("conversations/#{conversation_id}/reply", body: data)

  last_response.code == HTTP_CREATED
end

# File lib/help_scout.rb, line 182
def delete_conversation(id)
  delete("conversations/#{id}")
end

# File lib/help_scout.rb, line 290
def delete_customer_email(customer_id, email_id)
  delete("customers/#{customer_id}/emails/#{email_id}")
end

# File lib/help_scout.rb, line 276
def delete_customer_phone(customer_id, phone_id)
  delete("customers/#{customer_id}/phones/#{phone_id}")
end

# File lib/help_scout.rb, line 35
def generate_oauth_token
  options = {
    headers: {
      "Content-Type": "application/json"
    },
    body: {
      grant_type: "client_credentials",
      client_id: @api_key,
      client_secret: @api_secret,
    }
  }
  options[:body] = options[:body].to_json
  response = HTTParty.post("https://api.helpscout.net/v2/oauth2/token", options)
  JSON.parse(response.body)["access_token"]
end

# File lib/help_scout.rb, line 84
def get_conversation(id, embed_threads: false)
  if embed_threads
    get("conversations/#{id}?embed=threads")
  else
    get("conversations/#{id}")
  end
end

# File lib/help_scout.rb, line 249
def get_customer(id)
  get("customers/#{id}")
end

# File lib/help_scout.rb, line 189
def get_mailboxes
  get("mailboxes")
end

# File lib/help_scout.rb, line 173
def search_conversations(query)
  search("conversations", query)
end

# File lib/help_scout.rb, line 98
def update_conversation(id, data)
  instructions = []

  if data[:subject]
    instructions << {
      op: "replace",
      path: "/subject",
      value: data[:subject],
    }
  end
  if data[:mailboxId]
    instructions << {
      op: "move",
      path: "/mailboxId",
      value: data[:mailboxId],
    }
  end
  if data[:status]
    status = data[:status]
    if !CONVERSATION_STATUSES.include?(status)
      raise InvalidDataError.new("status \"#{status}\" not supported, must be one of #{CONVERSATION_STATUSES}")
    end

    instructions << {
      op: "replace",
      path: "/status",
      value: data[:status],
    }
  end
  if data.key?(:assignTo)
    # change owner
    if data[:assignTo]
      instructions << {
        op: "replace",
        path: "/assignTo",
        value: data[:assignTo],
      }
    else
      # un assign
      instructions << {
        op: "remove",
        path: "/assignTo",
      }
    end
  end

  # Note: HelpScout currently does not support multiple
  # instructions in the same request, well have to do them
  # individually :-)
  instructions.each do |instruction|
    patch("conversations/#{id}", { body: instruction })
  end
end

# File lib/help_scout.rb, line 163
def update_conversation_custom_fields(id, fields)
  data = { fields: fields }
  put("conversations/#{id}/fields", { body: data })
end

# File lib/help_scout.rb, line 155
def update_conversation_tags(id, tags)
  data = { tags: tags }
  put("conversations/#{id}/tags", { body: data })
end

# File lib/help_scout.rb, line 262
def update_customer(id, data)
  put("customers/#{id}", { body: data })
end

# File lib/help_scout.rb, line 312
def delete(path, options = {})
  request(:delete, path, options)
end

# File lib/help_scout.rb, line 308
def get(path, options = {})
  request(:get, path, options)
end

# File lib/help_scout.rb, line 316
def patch(path, options = {})
  options[:body] = options[:body].to_json if options[:body]

  request(:patch, path, options)
end

# File lib/help_scout.rb, line 296
def post(path, options = {})
  options[:body] = options[:body].to_json if options[:body]

  request(:post, path, options)
end

# File lib/help_scout.rb, line 302
def put(path, options = {})
  options[:body] = options[:body].to_json if options[:body]

  request(:put, path, options)
end

# File lib/help_scout.rb, line 339
def request(method, path, options)
  uri = URI("https://api.helpscout.net/v2/#{path}")

  token = @token_storage.token
  if token.nil?
    token = generate_oauth_token
    @token_storage.store_token(token)
  end

  options = {
    headers: {
      "Content-Type": "application/json",
      "Authorization": "Bearer #{token}",
    }
  }.merge(options)

  @last_response = HTTParty.send(method, uri, options)

  case last_response.code
  when HTTP_UNAUTHORIZED
    # Unauthorized means our token is expired. We will fetch a new one, and
    # retry the original request
    new_token = generate_oauth_token
    @token_storage.store_token(new_token)
    options.delete(:headers)
    request(method, path, options)
  when HTTP_OK, HTTP_CREATED, HTTP_NO_CONTENT
    last_response.parsed_response
  when HTTP_BAD_REQUEST
    raise ValidationError, JSON.parse(last_response.body)["_embedded"]["errors"]
  when HTTP_FORBIDDEN
    raise ForbiddenError
  when HTTP_NOT_FOUND
    raise NotFoundError
  when HTTP_INTERNAL_SERVER_ERROR
    error_message = JSON.parse(last_response.body)["error"]
    raise InternalServerError, error_message
  when HTTP_SERVICE_UNAVAILABLE
    raise ServiceUnavailable
  when HTTP_TOO_MANY_REQUESTS
    retry_after = last_response.headers["X-RateLimit-Retry-After"]
    message = "Rate limit of 200 RPM or 12 POST/PUT/DELETE requests per 5 " +
      "seconds reached. Next request possible in #{retry_after} seconds."
    raise TooManyRequestsError, message
  else
    raise NotImplementedError, "Help Scout returned something that is not implemented by the help_scout gem yet: #{last_response.code}: #{last_response.parsed_response["message"] if last_response.parsed_response}"
  end
end

# File lib/help_scout.rb, line 322
def search(path, query, page_id = 1, items = [])
  options = { query: { page: page_id, query: "(#{query})" } }

  result = get(path, options)
  next_page_id = page_id + 1

  if result.key?("_embedded")
    items += result["_embedded"]["conversations"]
  end

  if next_page_id > result["page"]["totalPages"]
    return items
  else
    search(path, query, next_page_id, items)
  end
end