module ViaBTC
  module HTTP
    class Client
      include ViaBTC::Helpers

      def initialize(url: nil, http_response: nil, http_adapter: nil)
        if ViaBTC.configuration
          url           ||= ViaBTC.configuration.http_base_url
          http_response ||= ViaBTC.configuration.http_response
          http_adapter  ||= ViaBTC.configuration.http_adapter
        end

        @connection ||= connection(url, http_response, http_adapter)
      end

      # Asset API

      def balance(user_id:, id: 0)
        request(id: id, method: 'balance.query', params: [user_id])
      end

      def withdraw(user_id:, asset:, withdraw_id:, amount:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        request(
          id: id,
          method: 'balance.update',
          params: [user_id, asset, 'withdraw', withdraw_id, amount, {source: source}]
        )
      end

      def deposit(user_id:, asset:, deposit_id:, amount:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        request(
          id: id,
          method: 'balance.update',
          params: [user_id, asset, 'deposit', deposit_id, amount, {source: source}]
        )
      end

      def balance_history(user_id:, asset:, business: '', start_time: 0, end_time: 0, offset: 0, limit: 100, id: 0)
        request(id: id, method: 'balance.history', params: [user_id, asset, business, start_time, end_time, offset, limit])
      end

      def asset_list
        request(method: 'asset.list', params: [])
      end

      def asset_summary
        request(method: 'asset.summary', params: [])
      end

      # Trade API

      def limit_sell(user_id:, market:, amount:, price:, taker_fee_rate:, maker_fee_rate:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{taker_fee_rate}" unless fee_rate_valid?(taker_fee_rate)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{maker_fee_rate}" unless fee_rate_valid?(maker_fee_rate)
        request(
          id: id,
          method: 'order.put_limit',
          params: [user_id, market, 1, amount, price, taker_fee_rate, maker_fee_rate, source]
        )
      end

      def limit_buy(user_id:, market:, amount:, price:, taker_fee_rate:, maker_fee_rate:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{taker_fee_rate}" unless fee_rate_valid?(taker_fee_rate)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{maker_fee_rate}" unless fee_rate_valid?(maker_fee_rate)
        request(
          id: id,
          method: 'order.put_limit',
          params: [user_id, market, 2, amount, price, taker_fee_rate, maker_fee_rate, source]
        )
      end

      def market_sell(user_id:, market:, amount:, taker_fee_rate:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{taker_fee_rate}" unless fee_rate_valid?(taker_fee_rate)
        request(
          id: id,
          method: 'order.put_market',
          params: [user_id, market, 1, amount, taker_fee_rate.to_s, source]
        )
      end

      def market_buy(user_id:, market:, amount:, taker_fee_rate:, source: 'web', id: 0)
        raise ViaBTC::Error::InvalidParameter, "invalid amount: #{amount}" unless amount_valid?(amount)
        raise ViaBTC::Error::InvalidParameter, "invalid fee rate #{taker_fee_rate}" unless fee_rate_valid?(taker_fee_rate)
        request(
          id: id,
          method: 'order.put_market',
          params: [user_id, market, 2, amount, taker_fee_rate.to_s, source]
        )
      end

      def cancel_order(user_id:, market:, order_id:, id: 0)
        request(id: id, method: 'order.cancel', params: [user_id, market, order_id])
      end

      def order_deals(order_id:, offset: 0, limit: 100, id:0)
        request(id: id, method: 'order.deals', params: [order_id, offset, limit])
      end

      def sell_orders(market:, offset: 0, limit: 100, id: 0)
        request(id: id, method: 'order.book', params: [market, 1, offset, limit])
      end

      def buy_orders(market:, offset: 0, limit: 100, id: 0)
        request(id: id, method: 'order.book', params: [market, 2, offset, limit])
      end

      def order_depth(market:, limit: 100, interval: '0', id: 0)
        request(id: id, method: 'order.depth', params: [market, limit, interval])
      end

      def pending_orders(user_id:, market:, offset: 0, limit: 100, id: 0)
        request(id: id, method: 'order.pending', params: [user_id, market, offset, limit])
      end

      def pending_order_details(order_id:, market:, id: 0)
        request(id: id, method: 'order.pending_detail', params: [market, order_id])
      end

      def finished_orders(user_id:, market:, start_time: 0, end_time: 0, offset: 0, limit: 100, side:0, id: 0)
        request(id: id, method: 'order.finished', params: [user_id, market, start_time, end_time, offset, limit, side])
      end

      def finished_sell_orders(user_id:, market:, start_time: 0, end_time: 0, offset: 0, limit: 100, side:1, id: 0)
        request(id: id, method: 'order.finished', params: [user_id, market, start_time, end_time, offset, limit, side])
      end

      def finished_buy_orders(user_id:, market:, start_time: 0, end_time: 0, offset: 0, limit: 100, side:2, id: 0)
        request(id: id, method: 'order.finished', params: [user_id, market, start_time, end_time, offset, limit, side])
      end

      def finished_order_detail(order_id:, id: 0)
        request(id: id, method: 'order.finished_detail', params: [order_id])
      end

      # Market API

      def market_last(market:, id: 0)
        request(id: id, method: 'market.last', params: [market])
      end

      def market_deals(market:, limit: 10000, last_id: 0, id: 0)
        request(id: id, method: 'market.deals', params: [market, limit, last_id])
      end

      def user_executed_orders(user_id:, market:, offset: 0, limit: 100, id: 0)
        request(id: id, method: 'market.user_deals', params: [user_id, market, offset, limit])
      end

      def market_kline(market:, start_time: now - 86400, end_time: now, interval: 3600, id: 0)
        request(id: id, method: 'market.kline', params: [market, start_time, end_time, interval])
      end

      def market_status(market:, period: 86400, id: 0)
        request(id: id, method: 'market.status', params: [market, period])
      end

      def market_status_today(market:, id: 0)
        market_status(market: market, period: 86400, id: id)
      end

      def market_list(id: 0)
        request(id: id, method: 'market.list', params: [])
      end

      def market_summary(id: 0)
        request(id: id, method: 'market.summary', params: [])
      end

      private

      def connection(url, http_response, http_adapter)
        raise ViaBTC::Error::Configuration, 'required: url' unless url
        http_response ||= :logger
        http_adapter ||= :net_http
        Faraday.new(url) do |conn|
          conn.response http_response
          conn.adapter http_adapter
          conn.headers['Content-Type'] = ['application/json']
        end
      end

      def request(method:, params:, id: 0)
        response = @connection.post do |req|
          req.body = {
            'id' => id,
            'method' => method,
            'params' => params
          }.to_json
        end
        response = JSON.parse(response.body)
        raise_exchange_error(response) if response_invalid?(response)
        response
      end
    end
  end
end