require 'active_support/core_ext/array'

module Biro
  module Spc
    class Response < BaseResponse
      def initialize(response)
        @body = response.body
      end

      def cpf
        person.dig(:cpf, :@numero)
      end

      def birthdate
        fetch_date(person.dig(:@data_nascimento))
      end

      def marital_status
        person.dig(:@estado_civil)
      end

      def mothers_name
        person.dig(:@nome_mae)
      end

      def fathers_name
        person.dig(:@nome_pai)
      end

      def rg
        person.dig(:@numero_rg)
      end

      def name
        person.dig(:@nome)
      end

      def voter_id
        person.dig(:@numero_titulo_eleitor)
      end

      def gender
        person.dig(:@sexo)
      end

      def income
        result.dig(:renda_presumida_spc, :resumo, :@valor_total)&.to_f&.round(2)
      end

      def receita_federal
        return nil unless rf

        { status: rf.dig(:@descricao_situacao), date: fetch_date(rf.dig(:@data_situacao)) }
      end

      def addresses
        [single_address] + all_addresses
      end

      def phones
        [single_phone] + all_phones
      end

      def defaults
        Array.wrap(spc).map do |d|
          {
            bureau: :spc,
            company: d.dig(:@nome_associado)&.strip,
            created_at: fetch_date(d.dig(:@data_inclusao)),
            due_at: fetch_date(d.dig(:@data_vencimento)),
            value: d.dig(:@valor)&.to_f,
            city: d.dig(:cidade_associado, :@nome),
            state: d.dig(:cidade_associado, :estado, :@sigla_uf),
            phone: { ddd: d.dig(:telefone_associado, :@numero_ddd), number: d.dig(:telefone_associado, :@numero) },
            contract: d.dig(:@contrato)
          }
        end
      end

      def scores
        [:spc_score_3_meses, :spc_score_12_meses].map do |score|
          next unless result.include? score

          fetch_score(result.dig(score))
        end.compact
      end

      def success?
        error.blank?
      end

      def error
        return nil unless registration.keys.first =~ /Erro/

        error = registration.flatten
        "#{error[0]} - #{error[1]['Mensagem']}"
      end

      def emails
        Array.wrap(person&.dig(:@email))
      end

      private

      def fetch_date(date)
        Time.parse(date)
      rescue
        nil
      end

      def all_phones
        phones = result.dig(:telefone_vinculado_consumidor, :detalhe_telefone_vinculado_consumidor)

        Array.wrap(phones).map do |p|
          phone = p.dig(:assinante, :telefone)
          fetch_phone(phone)
        end
      end

      def single_phone
        phone = person.dig(:telefone_residencial)
        return nil unless phone

        fetch_phone(phone)
      end

      def fetch_phone(phone)
        ddd = phone.dig(:@numero_ddd)
        number = phone.dig(:@numero)
        kind = (number.to_s[0] == '9' ? :mobile : :landline) if number

        { ddd: ddd, number: number, kind: kind }
      end

      def all_addresses
        Array.wrap(address&.fetch(:detalhe_ultimo_endereco_informado, nil)).map { |e| fetch_address(e) }
      end


      def single_address
        fetch_address(person)
      end

      def fetch_address(e)
        address = e.dig(:endereco)
        city = address&.dig(:cidade, :@nome)
        state = address&.dig(:cidade, :estado, :@sigla_uf)
        street = address&.dig(:@logradouro)
        number = address&.dig(:@numero)
        complement = address&.dig(:@complemento)
        zipcode = address&.dig(:@cep)

        {
          street: street,
          number: number,
          complement: complement,
          city: city,
          state: state,
          zipcode: zipcode
        }
      end

      def fetch_score(score)
        data = score&.values&.first

        { score_class: data.dig(:@classe), score: data.dig(:@score)&.to_i, period: data.dig(:@horizonte)&.to_i }
      end

      def address
        result.dig(:ultimo_endereco_informado)
      end

      def rf
        person.dig(:situacao_cpf)
      end

      def person
        result.dig(:consumidor, :consumidor_pessoa_fisica)
      end

      def spc
        result.dig(:spc, :detalhe_spc)
      end

      def result
        @body.dig(:resultado)
      end
    end
  end
end