module Worker
  class EthClientToHot
    attr_accessor :params, :rpc, :from_address, :fee

    def initialize
      @logger = Logger.new("#{Rails.root}/log/check_erc20_to_huobi.log")
    end

    def process(payload, metadata, delivery_info)
      format_payload(payload)
      params_data = create_from_payload(payload)
      return nil unless params_data[:address]
      process_transactions(params_data, payload)
    rescue => error
      ExceptionNotifier.notify_exception(error, data: {payload: payload})
      raise $!
    end

    def format_payload(payload)
      payload.symbolize_keys!
      @logger.info payload
    end

    def create_from_payload(payload)
      @rpc ||= Rpc.send(payload[:coin])
      @from_address ||= payload[:from]
      {
        gas_price: get_gas_price,
        amount: payload[:amount].to_d,
        address: get_address(payload[:coin], amount),
        gas_limit: get_gas_limit
      }
    end

    def get_gas_price
      @logger.info rpc.get_gas_price
    end

    def get_address(coin, amount)
      @logger.info 'address'
      @logger.info check_min_deposit(coin, amount)
    end

    def check_min_deposit(coin, amount)
      response = rpc.huobi_deposit_address

      if respose.blank? || insufficient_deposit?(coin, amount)
        rpc.config['hot_wallet']
      else
        response['data']['address']
      end
    end

    def insufficient_deposit?(coin, amount)
      asset = Asset.find(coin)
      asset.min_deposit > amount
    end

    def get_gas_limit
      @logger.info rpc.get_gas_limit(params)
    end

    def process_transactions(params_data, payload)
      create_transaction_params(params_data)
      insufficient_balance_transaction if balance_less_fee?
      transfer_to_huobi_wallet(payload)
    end

    def create_transaction_params(params_data)
      create_params(params_data)
      gas_limit = get_gas_limit
      update_params(gas_limit)
      create_fee(gas_limit, params_data)
    end

    def create_params(params_data)
      @params ||= rpc.params_for_transaction(
        from_address,
        params_data[:address],
        params_data[:amount],
        params_data[:gas_price]
      )
    end

    def update_params(gas_limit)
      params[:gas] = "0x#{gas_limit.to_s(16)}"
      @logger.info params
    end

    def create_fee(gas_limit, params_data)
      @fee ||= gas_limit * params_data[:gas_price] / 1e+18
    end

    def balance_less_fee?
      rpc_eth.get_balance(from_address) < fee
    end

    def rpc_eth
      @rpc_eth ||= Rpc.eth
    end

    def insufficient_balance_transaction
      @logger.info "balance < #{fee}"
      from = get_from_address(fee)
      @logger.info 'from address'
      @logger.info from

      if from
        create_rpc_transaction
      else
        withdraw_insufficient_funds
      end
    end

    def get_from_address(fee)
      if rpc_eth.get_balance(CONFIG_ETH['erc20_fee_wallet']) > fee * 3
        CONFIG_ETH['erc20_fee_wallet']
      elsif rpc_eth.get_balance(CONFIG_ETH['hot_wallet']) > fee * 3
        SystemMailer.not_enough_balance('ETH fee').deliver
        CONFIG_ETH['hot_wallet']
      end
    end

    def create_rpc_transaction
      @logger.info "create transaction amount: #{fee}"
      @logger.info rpc_eth.create_transaction(from: from, to: from_address, amount: fee)
    end

    def withdraw_insufficient_funds
      SystemMailer.withdraw_insufficient_funds(
        'Low balance to process Withdraw to huobi , amount < 0.006 ETH for erc20.'
      ).deliver
      # SystemMailer.not_enough_balance("ETH fee").deliver
    end

    def transfer_to_huobi_wallet(payload, retry_count = 100)
      log_retry(retry_count)
      return if retry_count.zero?
      sleep 1.minute

      if balance_less_fee?
        @logger.info "balance < #{fee}"
        transfer_to_huobi_wallet(payload, retry_count - 1)
      else
        rpc_send_transaction(payload, retry_count)
      end
    end

    def log_retry(retry_count)
      @logger.info 'try transfer_to_huobi_wallet'
      @logger.info retry_count
    end

    def rpc_send_transaction(payload, retry_count)
      @logger.info 'start transaction'
      @logger.info 'create transaction'
      txid = rpc.send_transaction(params)
      @logger.info txid

      if txid
        update_huobi_txid(payload)
      else
        sleep 1.minute
        transfer_to_huobi_wallet(payload, retry_count - 1)
      end
    end

    def update_huobi_txid(payload)
      PSIM::Deposit.find(payload[:deposit_id]).update(huobi_txid: txid)
      @logger.info txid
    end
  end
end