# frozen_string_literal: true

require('bigdecimal/util')

# @author Hernani Rodrigues Vaz
module Krkt
  # classe para processar carteiras & transacoes normais e ledgers
  class Kraken
    # @return [Client] API kraken
    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 & ledgers?
    # @return [Kraken] API kraken - processar transacoes normais e ledgers
    def initialize(dad, pop)
      @api = Client.new
      @dbq = dad
      @ops = pop
    end

    # @return [Array<Hash>] todos os dados kraken - saldos & transacoes
    def dkr
      @dkr ||= {
        sl: api.balance,
        kt: api.trades_history,
        kl: api.ledgers
      }
    end

    # @return [Array<Integer>] lista blocknumbers de transacoes normais
    def kyt
      @kyt ||= dkr[:kt]['trades'].keys - (ops[:t] ? [] : dbq[:nt].map { |e| e[:txid] })
    end

    # @return [Array<Integer>] lista blocknumbers de transacoes ledger
    def kyl
      @kyl ||= dkr[:kl]['ledger'].keys - (ops[:t] ? [] : dbq[:nl].map { |e| e[:txid] })
    end

    # @return [Array<Hash>] lista transacoes novas trades
    def trades
      @trades ||= dkr[:kt]['trades'].select { |k, _| kyt.include?(k) }
    end

    # @return [Array<Hash>] lista transacoes novas ledger
    def ledger
      @ledger ||= dkr[:kl]['ledger'].select { |k, _| kyl.include?(k) }
    end

    # def formata_saldos(moe, sal)
    def formata_saldos(moe, sal)
      t = dbq[:sl][moe.downcase.to_sym].to_d
      format(
        '%<mo>-5.5s %<kr>21.9f %<bq>21.9f %<ok>3.3s',
        mo: moe,
        kr: sal,
        bq: t,
        ok: t == sal ? 'OK' : 'NOK'
      )
    end

    # @parm [Hash] htx transacao normal
    # @return [String] texto formatado transacao normal
    def formata_transacao_trades(idx, htx)
      format(
        '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-8.8s %<pr>8.2f %<vl>15.7f %<co>8.2f',
        ky: idx,
        dt: Time.at(htx['time']),
        ty: "#{htx['type']}/#{htx['ordertype']}",
        mo: htx['pair'],
        pr: htx['price'].to_d,
        vl: htx['vol'].to_d,
        co: htx['cost'].to_d
      )
    end

    # @parm [Hash] hlx transacao ledger
    # @return [String] texto formatado transacao ledger
    def formata_transacao_ledger(idx, hlx)
      format(
        '%<ky>-6.6s %<dt>19.19s %<ty>-10.10s %<mo>-4.4s %<pr>18.7f %<vl>18.7f',
        ky: idx,
        dt: Time.at(hlx['time']),
        ty: hlx['type'],
        mo: hlx['asset'],
        pr: hlx['amount'].to_d,
        vl: hlx['fee'].to_d
      )
    end

    # @return [String] texto saldos & transacoes & ajuste dias
    def mostra_resumo
      puts("\nmoeda        saldo bigquery          saldo kraken")
      dkr[:sl].each { |k, v| puts(formata_saldos(k, v.to_d)) }

      mostra_trades
      mostra_ledger
      return unless trades.count.positive?

      puts("\nstring ajuste dias dos trades\n-h=#{kyt.map { |e| "#{e}:0" }.join(' ')}")
    end

    # @return [String] texto transacoes normais
    def mostra_trades
      return unless ops[:v] && trades.count.positive?

      puts("\ntrade  data       hora     tipo       par      ---preco ---------volume ---custo")
      trades.each { |k, v| puts(formata_transacao_trades(k, v)) }
    end

    # @return [String] texto transacoes ledger
    def mostra_ledger
      return unless ops[:v] && ledger.count.positive?

      puts("\nledger data       hora     tipo       moeda -------quantidade -------------custo")
      ledger.each { |k, v| puts(formata_transacao_ledger(k, v)) }
    end
  end
end