# frozen_string_literal: true

require('bigdecimal/util')

# @author Hernani Rodrigues Vaz
module Etht
  # classe para processar carteiras & transacoes normais e tokens
  class Carteiras
    # @return [Etherscan] API etherscan
    attr_reader :api
    # @return [Array<Hash>] todos os dados bigquery
    attr_reader :dbq
    # @return [Thor::CoreExt::HashWithIndifferentAccess] opcoes trabalho
    attr_reader :ops

    # @param [Hash] dad todos os dados bigquery
    # @param [Thor::CoreExt::HashWithIndifferentAccess] pop opcoes trabalho
    # @option pop [Hash] :h ({}) configuracao dias ajuste reposicionamento temporal
    # @option pop [Boolean] :v (false) mostra dados transacoes normais & tokens?
    # @return [Carteiras] API etherscan - processar transacoes normais e tokens
    def initialize(dad, pop)
      @api = Etherscan.new
      @dbq = dad
      @ops = pop
      p(ops)
    end

    # @return [Array<Hash>] todos os dados etherscan - saldos & transacoes
    def des
      @des ||= api.multi_address_balance(dbq[:wb].map { |c| c[:ax] }).map { |e| base_etherscan(e) }
    end

    # @return [Array<Hash>] todos os dados juntos bigquery & etherscan
    def djn
      @djn ||= dbq[:wb].map { |b| bigquery_etherscan(b, des.select { |s| b[:ax] == s[:ax] }.first) }
    end

    # @return [Array<Integer>] lista blocknumbers de transacoes normais
    def bnt
      @bnt ||= (des.map { |e| e[:tx].map { |n| Integer(n['blockNumber']) } }.flatten -
               (ops[:t] ? [] : dbq[:nt].map { |t| t[:blocknumber] })).uniq
    end

    # @return [Array<Integer>] lista blocknumbers de transacoes token
    def bnk
      @bnk ||= (des.map { |e| e[:kx].map { |n| Integer(n['blockNumber']) } }.flatten -
               (ops[:t] ? [] : dbq[:nk].map { |t| t[:blocknumber] })).uniq
    end

    # @return [Array<Hash>] lista transacoes normais
    def norml
      @norml ||= des.map { |e| e[:tx].select { |s| bnt.include?(Integer(s['blockNumber'])) } }.flatten.uniq
    end

    # @return [Array<Hash>] lista transacoes tokan
    def token
      @token ||= des.map { |e| e[:kx].select { |s| bnk.include?(Integer(s['blockNumber'])) } }.flatten.uniq
    end

    # @return [Array<Hash>] lista ordenada transacoes normais
    def norml_sort
      norml.sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
    end

    # @return [Array<Hash>] lista ordenada transacoes tokan
    def token_sort
      token.sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
    end

    # @return [Array<Hash>] lista ordenada todas as transacoes (normais & tokan)
    def todas_sort
      (norml + token).sort { |a, b| Integer(a['blockNumber']) <=> Integer(b['blockNumber']) }
    end

    # @param [Hash] hes dados etherscan
    # @return [Hash] dados etherscan - address, saldo & transacoes
    def base_etherscan(hes)
      {
        ax: hes['account'],
        sl: (hes['balance'].to_d / 10**18).round(10),
        tx: etherscan_tx(hes['account']),
        kx: etherscan_kx(hes['account'])
      }
    end

    # @param [Hash] hbq dados bigquery
    # @param [Hash] hes dados etherscan
    # @return [Hash] dados juntos bigquery & etherscan
    def bigquery_etherscan(hbq, hes)
      {
        id: hbq[:id],
        ax: hbq[:ax],
        bs: hbq[:sl],
        bt: dbq[:nt].select { |t| t[:iax] == hbq[:ax] },
        bk: dbq[:nk].select { |t| t[:iax] == hbq[:ax] },
        es: hes[:sl],
        et: hes[:tx],
        ek: hes[:kx]
      }
    end

    # @param add (see formata_endereco)
    # @return [Array<Hash>] lista transacoes normais ligadas a uma carteira - sem elementos irrelevantes
    def etherscan_tx(add)
      api.normal_tx(add).map do |e|
        e.delete('cumulativeGasUsed')
        e.delete('confirmations')
        e
      end
    end

    # @param add (see formata_endereco)
    # @return [Array<Hash>] lista transacoes token ligadas a uma carteira - sem elementos irrelevantes
    def etherscan_kx(add)
      api.token_tx(add).map do |e|
        e.delete('cumulativeGasUsed')
        e.delete('confirmations')
        e
      end
    end
  end
end