class Patrimonio::BemPatrimonial < ApplicationRecord
  include EnumIsh::Base
  include SimConcern
  include TradutorConcern
  include AASM

  ransacker :numero_do_tombamento_numeric, formatter: proc { |v| v.to_f } do |parent|
    Arel.sql("CAST(patrimonio_bens_patrimoniais.numero_do_tombamento AS BIGINT)")
  end

  has_paper_trail

  attr_default :status, :ativo
  attr_default :data_do_tombamento, Date.today
  attr_default :inicio_da_depreciacao, Date.today + 1.month
  attr_default :tipo_de_depreciacao, :normal

  attr_accessor :estado_do_bem
  attr_accessor :eh_de_recebimento

  belongs_to :unidade_gestora, class_name: 'Loa::UnidadeGestora'
  belongs_to :item_do_recebimento_de_bem, class_name: 'Patrimonio::ItemDoRecebimentoDeBem'
  belongs_to :item_da_transferencia, class_name: 'Patrimonio::ItemDaTransferencia'
  belongs_to :dados_extras_do_bem, class_name: 'Patrimonio::DadosExtrasDoBem', required: true
  belongs_to :orcamento, class_name: 'Orcamento'
  belongs_to :programa_de_recursos, class_name: 'Patrimonio::ProgramaDeRecursos'
  belongs_to :item, class_name: 'Base::Item'
  belongs_to :sub_elemento_de_despesa, class_name: "Contabilidade::SubElementoDeDespesa"
  belongs_to :localizacao_atual, class_name: 'Patrimonio::LocalizacaoDoBem', foreign_key: :localizacao_atual_id
  belongs_to :depreciacao_atual, class_name: 'Patrimonio::DepreciacaoDoBem', foreign_key: :depreciacao_atual_id

  has_many :conservacoes_dos_bens, class_name: 'Patrimonio::ConservacaoDoBem', dependent: :destroy
  has_many :localizacoes_dos_bens, class_name: 'Patrimonio::LocalizacaoDoBem', dependent: :destroy
  has_many :responsaveis_do_bem_patrimonial, class_name: 'Patrimonio::ResponsavelDoBemPatrimonial', dependent: :destroy
  has_many :fotos_do_bem_patrimonial, class_name: 'Patrimonio::FotoDoBemPatrimonial'
  has_many :movimentacoes_financeiras_dos_bens, class_name: 'Patrimonio::MovimentacaoFinanceiraDoBem', dependent: :destroy
  has_many :vidas_uteis_dos_bens, class_name: 'Patrimonio::VidaUtilDoBem'
  has_many :alteracoes_dos_valores_dos_bens, class_name: 'Patrimonio::AlteracaoDoValorDoBem'
  has_many :avaliacoes_dos_bens, class_name: 'Patrimonio::AvaliacaoDoBem'
  has_many :depreciacoes_dos_bens, class_name: 'Patrimonio::DepreciacaoDoBem'
  has_many :linhas, as: :modulo, class_name: "Tcm::Linha", dependent: :destroy
  has_many :bens_patrimoniais_da_requisicao, class_name: 'Patrimonio::BemPatrimonialDaRequisicao'

  has_one :recebimento_de_bem, through: :item_do_recebimento_de_bem
  has_one :recebimento_de_material, through: :recebimento_de_bem
  has_one :desafetacao_do_bem, class_name: 'Patrimonio::DesafetacaoDoBem'
  has_one :baixa_do_bem, class_name: 'Patrimonio::BaixaDoBem'

  accepts_nested_attributes_for :fotos_do_bem_patrimonial, reject_if: Proc.new{ |atributo| atributo['foto'].blank? }, allow_destroy: true

  before_validation :recebe_data_do_tombamento

  before_create :atribui_tipo_de_poder

  validates_presence_of :estado_do_bem, unless: Proc.new { Rails.env.test? }
  validates_presence_of :data_do_tombamento, :item_do_recebimento_de_bem_id, :numero_do_tombamento, if: Proc.new { self.dados_extras_do_bem.tombamento_manual.to_boolean == true }

  validates_uniqueness_of :numero_do_tombamento, scope: :tipo_de_poder, message: "Número de tombamento %{value}, já foi utilizado"

  validate :valida_data_de_inicio_da_depreciacao, if: :new_record?
  # validate :valida_data_de_tombamento

  after_save :gerar_numero_do_tombamento, if: Proc.new { self.numero_do_tombamento.blank? && self.sequencia.to_i > 0 }
  after_create :definir_item_id_e_sub_elemento
  after_create :gera_conservacao_do_bem_inicial
  after_create :gerar_movimentacao_financeira_do_tombamento

  scope :exceto_essas_contas, -> {
    joins(:sub_elemento_de_despesa).where.not("CAST(contabilidade_sub_elementos_de_despesa.codigo AS integer) in (?)", [25])
  }

  scope :disponiveis, -> {
    where(status: :ativo)
  }

  scope :numero_real_tombamento, -> (tombo) {where("LTRIM(patrimonio_bens_patrimoniais.numero_do_tombamento, '0') = ?", tombo.to_i.to_s)}

  def self.ransackable_scopes(auth_object = nil)
    [:numero_real_tombamento]
  end

  enum_ish :estado_do_bem, ['novo', 'bom', 'regular', 'pessimo', 'ocioso', 'recuperavel', 'antieconomico', 'inservivel_irrecuperavel'], default: 'novo'

  enum tipo_de_poder: {
    executivo: 1,
    legislativo: 2
  }

  enum tipo_de_bem: {
    bem_movel: 1,
    bem_imovel: 2
  }

  enum status:{
    ativo: 1,
    em_processamento: 2,
    leilao: 3,
    desafetado: 4,
    desreconhecido_para_ajuste: 5,
    desreconhecido: 6
  }

  enum status_complementar:{
    cedido: 1,
    nao_cedido: 2
  }

  enum tipo_de_combustivel:{
    gasolina: 1,
    alcool: 2,
    eletrico: 3,
    flex: 4
  }

  enum origem_do_recurso: {
    recurso_proprio: 1,
    convenio: 2,
    transf_legais_automaticas: 3,
    transf_legais_fundo_a_fundo: 4,
    transf_constitucionais: 5,
    pessoa_fisica_juridica: 6,
    nao_aplicavel: 7
  }

  enum tipo_de_depreciacao: {
    normal: 1,
    acelerada: 2
  }

  aasm column: :status_complementar, enum: true, whiny_transitions: false do
		state :nao_cedido, :initial => true
		state :cedido

		event :ceder do
			transitions to: :cedido
		end

		event :devolver do
			transitions to: :nao_cedido
		end

	end

  def definir_item_id_e_sub_elemento
    if self.item_do_recebimento_de_bem.present?
      self.item_id = self.item_do_recebimento_de_bem.item_id
      self.sub_elemento_de_despesa_id = self.item_do_recebimento_de_bem.recebimento_de_bem.sub_elemento_de_despesa_id
      conta_pcasp = Patrimonio::DepreciacaoVidaUtilConfiguracao.find_by(sub_elemento_de_despesa: self.sub_elemento_de_despesa.codigo)
      self.pcasp_estendido = conta_pcasp.conta_pcasp
    end
  end

  def unidade_gestora_atual
    if self.localizacao_atual.present?
      if self.localizacao_atual.centro_de_custo.centro_de_custos_mae_principal.present?
        self.localizacao_atual.centro_de_custo.centro_de_custos_mae_principal.unidade_gestora
      else
        self.localizacao_atual.centro_de_custo.unidade_gestora
      end
    else
      self.unidade_gestora
    end
  end

  def definir_nova_localizacao_atual
    ulti_local = self.localizacoes_dos_bens
                     .select(:id)
                     .order(data_de_inicio_na_localizacao: :desc, id: :desc)
                     .limit(1)
                     .pluck(:id)
                     .first
  
    self.update_column(:localizacao_atual_id, ulti_local) if ulti_local && ulti_local != localizacao_atual_id
  end
  
  def gerar_numero_do_tombamento
    modelo_numeracao = Configuracao.first.numeracao_do_tombamento
    quantidade_numerica = modelo_numeracao.count('9')
    index_ano = modelo_numeracao.index('A')
    index_numeracao = modelo_numeracao.index('9')

    sequencia_ajustada = self.sequencia.to_s.rjust(quantidade_numerica, '0')
    if index_ano == 0
      self.numero_do_tombamento = "#{self.orcamento.exercicio}#{sequencia_ajustada}"
    else
      self.numero_do_tombamento = "#{sequencia_ajustada}#{self.orcamento.exercicio}"
    end
    self.save
  end

  def gerar_movimentacao_financeira_do_tombamento
    movimentacao_financeira_do_tombamento = Patrimonio::MovimentacaoFinanceiraDoBem.create!(
      bem_patrimonial_id: self.id,
      data_da_movimentacao: self.data_do_tombamento,
      valor_inicial: 0,
      valor_da_operacao: self.dados_extras_do_bem.valor_de_aquisicao,
      valor_final: self.dados_extras_do_bem.valor_de_aquisicao
    )
  end

  def gerar_foto_dos_outros_bens_de_msm_recebimento
    outros_bens_do_msm_receb = self.recebimento_de_bem.bens_patrimoniais.where('patrimonio_bens_patrimoniais.id <> ? AND patrimonio_bens_patrimoniais.item_do_recebimento_de_bem_id = ?', self.id, self.item_do_recebimento_de_bem.id )
    outros_bens_do_msm_receb.each do |bem|
      self.fotos_do_bem_patrimonial.each do |foto|
        if !bem.fotos_do_bem_patrimonial.map{ |f| f.foto_file_name == foto.foto_file_name }.any?
          Patrimonio::FotoDoBemPatrimonial.create(bem_patrimonial_id: bem.id, foto: foto.foto)
        end
      end
    end
  end

  def valida_data_de_inicio_da_depreciacao
    if inicio_da_depreciacao.present? && data_do_tombamento.present?
      errors.add(:inicio_da_depreciacao, 'O Início da Deprecição deve ser no minimo 30 dias depois da data de tombamento.') if (inicio_da_depreciacao.mjd - data_do_tombamento.to_date.mjd) < 30
    end
  end

  def valida_data_de_tombamento
    if data_do_tombamento.present?
      errors.add(:data_do_tombamento, 'A Data de tombamento não pode ser anterior ao mês atual.') if Date.today.month > data_do_tombamento.to_date.month
    end
  end

  def recebe_data_do_tombamento
    if self.data_do_tombamento.nil? && self.dados_extras_do_bem.data_do_tombamento.present?
      self.data_do_tombamento = self.dados_extras_do_bem.data_do_tombamento
    end
  end

  def conservacao_do_bem_atual
    conservacao_do_bem = self.conservacoes_dos_bens.order('data_da_conservacao desc, estado_do_bem desc').first
    conservacao_do_bem.try(:estado_do_bem_i18n)
  end

  def gera_conservacao_do_bem_inicial
    conservacao_do_bem = Patrimonio::ConservacaoDoBem.create!(
      bem_patrimonial_id: self.id,
      estado_do_bem: estado_do_bem,
      data_da_conservacao: self.data_do_tombamento
    )
  end

  def gera_localizacao_do_bem_inicial(localizacao)
    centro_de_custo = Controladoria::CentroDeCusto.find_by(id: localizacao.to_i)
    centro_nivel_1 = centro_de_custo
    nivel_count = 0

    while centro_nivel_1&.nivel != 1 && nivel_count < 5
      centro_nivel_1 = centro_nivel_1.centro_de_custos_mae
      nivel_count += 1
    end

    responsavel = centro_de_custo.responsavel_atual.presence || centro_nivel_1&.responsavel_atual_patrimonial

    if responsavel.nil?
      centro_de_custo_mae = Controladoria::CentroDeCusto.find(centro_de_custo.centro_de_custos_mae_id)
      responsavel = centro_de_custo_mae.responsavel_do_centro_de_custos
    end

    localizacao = Patrimonio::LocalizacaoDoBem.create!(
      bem_patrimonial_id: self.id,
      centro_de_custo_id: centro_de_custo.id,
      agente_publico_municipal: responsavel.agente_publico_municipal,
      status: 2,
      data_de_inicio_na_localizacao: self.data_do_tombamento
    )

    responsavel_do_bem = Patrimonio::ResponsavelDoBemPatrimonial.create!(
      bem_patrimonial_id: self.id,
      pessoa_id: responsavel.agente_publico_municipal.pessoa.id,
      data_inicio: self.data_do_tombamento,
      tipo_de_responsavel: centro_de_custo_mae.present? ? 2 : 1
    )
    self.update_column(:localizacao_atual_id, localizacao.id) if localizacao.present?

  end

  def numero_do_tombamento_e_descricao
    "#{self.numero_do_tombamento} - #{self.try(:item).try(:descricao)}"
  end

  def ultima_avaliacao
    self.avaliacoes_dos_bens.last
  end

  def tem_reavaliacoes?
    self.avaliacoes_dos_bens.any?
  end

  def pode_ser_reavaliado?
    !self.tem_reavaliacoes? #|| self.tem_reavaliacoes? && self.avaliacoes_dos_bens.last.data_da_avaliacao
  end

  def atualiza_status
    # self.confirmar_recebimento_almoxarifado!
	end

  def eh_de_veiculo?
    # if ['01', '10', '28', '30'].include?(self.sub_elemento_de_despesa.codigo)
    if ['02', '20', '48', '50', '52', '53'].include?(self.sub_elemento_de_despesa.codigo)
      return true
    else
      return false
    end
  end

  def tipo_de_label_status
    if self.ativo?
      'success'
    elsif self.em_processamento?
      'info'
    elsif self.leilao?
      'warning'
    else
      'danger'
    end
  end

  def tipo_de_label_conservacao
    conservacao_do_bem = self.conservacao_do_bem_atual
    if conservacao_do_bem == 'Novo' || conservacao_do_bem == 'Bom'
      'success'
    elsif conservacao_do_bem == 'Ocioso' || conservacao_do_bem == 'Recuperável'
      'info'
    elsif conservacao_do_bem == 'Regular' || conservacao_do_bem == 'Antieconômico'
      'warning'
    else
      'danger'
    end
  end

  def ultima_depreciacao
    self.depreciacoes_dos_bens.order(data_depreciacao: :desc).first
  end

  def depreciacao_no_periodo(data_inicial, data_final)
    self.depreciacoes_dos_bens.where('data_depreciacao BETWEEN ? AND ?', data_inicial, data_final).sum(:valor_depreciado).real_contabil
  end

  def depreciacao_ate_data(data)
    self.depreciacoes_dos_bens.where('data_depreciacao <= ?', data).sum(:valor_depreciado)
  end

  def existe_foto_do_bem_patrimonial?
    self.fotos_do_bem_patrimonial.present?
  end

  def ultima_conservacao_do_bem
    self.conservacoes_dos_bens.order('data_da_conservacao desc, estado_do_bem desc').first
  end

  # def localizacao_atual
  #   Patrimonio::LocalizacaoDoBem.find_by(id: self.localizacao_atual_id)
  #   # localizacoes_dos_bens.order(data_de_inicio_na_localizacao: :desc).first
  # end

  def localizacao_na_data(data)
    localizacoes_dos_bens.where('data_de_inicio_na_localizacao <= ?', data.end_of_month).order('data_de_inicio_na_localizacao DESC').first
  end

  def localizacao_apartir_de(data)
    localizacoes_dos_bens.where('data_de_inicio_na_localizacao >= ?', data).order('data_de_inicio_na_localizacao ASC').last
  end

  def descricao_do_local_atual
    Patrimonio::LocalizacaoDoBem.find_by(id: self.localizacao_atual_id).try(:centro_de_custo)
  end

  def responsavel_do_local_atual
    Patrimonio::LocalizacaoDoBem.find_by(id: self.localizacao_atual_id).try(:agente_publico_municipal)
  end

  def vida_util_remanescente
    # start_date = Time.new(self.data_do_tombamento.year, self.data_do_tombamento.month, self.data_do_tombamento.day)
    # end_date = Time.new(Date.today.year, Date.today.month, Date.today.day)

    # days = (Date.today.to_time.to_i / 86400) - (self.data_do_tombamento.to_time.to_i / 86400)
    # return (Date.today.year - self.data_do_tombamento.year))

    # return ((10 * 12 ) - (days /30.44)).round(2)

    if self.tem_reavaliacoes?
      return ((self.ultima_avaliacao.try(:vida_util)) - (Date.today.year - self.ultima_avaliacao.try(:data_da_avaliacao).try(:year))) rescue 0
    else
      return ((self.dados_extras_do_bem.vida_util) - (Date.today.year - self.data_do_tombamento.year))
    end
  end

  def valor_atualizado_do_bem_patrimonial
    self.movimentacoes_financeiras_dos_bens.sum(:valor_da_operacao)
  end

  def valor_atualizado_do_bem_ate_data(data)
    self.movimentacoes_financeiras_dos_bens.where('data_da_movimentacao <= ?', data).sum(:valor_da_operacao)
  end

  def valor_depreciado_do_bem
    self.movimentacoes_financeiras_dos_bens.where(origem_type: 'Patrimonio::DepreciacaoDoBem').sum(:valor_da_operacao)
  end

  def ultima_movimentacao_ate_data(data)
    self.movimentacoes_financeiras_dos_bens.where('data_da_movimentacao >= ? AND data_da_movimentacao <= ?', data.beginning_of_year, data).order('data_da_movimentacao DESC').first
  end

  def unidade_orcamentaria(gestora_id, exercicio)
    unid = Loa::UnidadeOrcamentaria.joins(:unidade_gestora).joins(orgao: :orcamento).where("loa_unidades_gestoras.id = #{gestora_id} AND orcamentos.exercicio = #{exercicio}").order(:codigo).first

    ultima_unid_disponivel = Loa::UnidadeOrcamentaria.joins(:unidade_gestora).joins(orgao: :orcamento).where("loa_unidades_gestoras.id = #{gestora_id}").order('orcamentos.exercicio DESC').first

    unid = unid.nil? ? Loa::UnidadeOrcamentariaVinculada.find_by_unidade_orcamentaria_vinculada_id(ultima_unid_disponivel.id).unidade_orcamentaria : unid

    unid = unid.nil? ? ultima_unid_disponivel : unid

    return unid
  end

  def atribui_tipo_de_poder
    poder = nil
    if self&.recebimento_de_bem&.unidade_orcamentaria.present?
      poder = self.recebimento_de_bem.unidade_orcamentaria.tipo_de_unidade_administrativa.poder_associado.to_sym
    elsif self.data_do_tombamento.present? && unidade_gestora.present?
      poder = unidade_orcamentaria(unidade_gestora_id, data_do_tombamento.year).tipo_de_unidade_administrativa.poder_associado
    end
    self.tipo_de_poder = poder
  end

  def enviado_ao_sim?
		arquivo_id.present? && arquivo_id > 0
	end

  def tombamento_to_sim(unidade_orcamentaria_id)
    if tombamento_sim.present?
      tombamento = tombamento_sim.sim_descricao
    else
      sigla_uo = Loa::UnidadeOrcamentaria.find(unidade_orcamentaria_id)&.sigla.to_s.gsub(/\s+/, "")
      tombamento = "#{sigla_uo}#{self.numero_do_tombamento.sim_preenche(20 - sigla_uo.size).delete('"')}"
      self.update_column(:tombamento_sim, tombamento)
    end
    return tombamento
  end

  def to_sim(data_referencia)
    # agente = self.localizacao_na_data(self.data_do_tombamento).agente_publico_municipal
    uo = unidade_orcamentaria(self.unidade_gestora_id, data_referencia.year)
    agente = uo.unidade_gestora.gestor_no_periodo(data_referencia.end_of_month)
    valor_depriciavel = self.dados_extras_do_bem.valor_de_aquisicao.to_d - self.dados_extras_do_bem.valor_residual.to_d

    begin
			texto = ""
			texto << "980".sim_preenche(3) + "," #1
			texto << Configuracao.first.codigo_do_municipio_no_tcm.sim_preenche(3) + "," #2
      texto << tombamento_to_sim(uo.id).sim_limite(20) + "," #3
      texto << data_referencia.sim_data.first(6) + "," #4
      texto << self.data_do_tombamento.sim_data + "," #5
      texto << self.item.descricao.sim_descricao.sim_limite(510) + "," #6
      texto << self.pcasp_estendido.to_s.sim_preenche_a_direita(15) + "," #7
      texto << (self.item_do_recebimento_de_bem.present? ? '1' : '2') + "," #8
      texto << data_referencia.sim_data.first(4) + '00' + "," #9
      texto << uo.orgao.codigo.sim_preenche(2) + "," #10
      texto << uo.codigo.codigo_uo_to_sim + "," #11
      texto << agente.cpf.sim_limite(11) + "," #12
      texto << agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).to_s.sim_preenche(1) + "," #13
      texto << agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).to_s.sim_preenche(1) + "," #14
      texto << agente.numero_da_portaria.to_s.sim_limite(10) + "," #15
      # texto << (agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).present? ? agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).to_s : ).sim_preenche(1) + "," #13
      # texto << (agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).present? ? agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).to_s : "E").sim_preenche(1) + "," #14
      # texto << (agente.numero_da_portaria.to_s == '' ? 'PORTARIA' : agente.numero_da_portaria.to_s).sim_limite(10) + "," #15
      texto << self.dados_extras_do_bem.valor_de_aquisicao.to_d.to_s.sim_valor + "," #16
      texto << self.dados_extras_do_bem.valor_residual.to_d.to_s.sim_valor + "," #17
      texto << valor_depriciavel.to_d.to_s.sim_valor + "," #18
      texto << self.dados_extras_do_bem.vida_util.to_i.to_s.sim_limite(2) + "," #19

      if self.bem_imovel?
        #seá necessaŕio ajustar após ser realizado ajustes na tabela de localização do bem.
        localizacao = self.localizacoes_dos_bens.where('data_de_inicio_na_localizacao <= ?', data_referencia.end_of_month).order(:data_de_inicio_na_localizacao).last

        texto << localizacao.endereco_completo_do_bem.sim_descricao.sim_limite(255) + "," #20
        texto << "Distrito/Localidade".sim_descricao.sim_limite(150) + "," #21
        texto << "Latitude".sim_limite(6) + "," #22
        texto << "Longitude".sim_limite(6) + "," #23
        texto << "Matrícula do Registro".sim_limite(20) + "," #24
        texto << "Zona Cartorial".sim_limite(2) + "," #25
        texto << "Município do Cartório".sim_limite(30) + "," #26
        texto << "0.00" #27

      else
        (20..26).each do |linha|
          texto << "".sim_limite(2) + "," #20 - 26
        end

        texto << "0.00" #27
      end

      return texto
		rescue => e
			if e.class.to_s == "NoMethodError"
				atributo_falho = e.message.split(" ")[2]
				coluna = CSV.parse(texto, :headers => false).last.count
				raise e.mensagem_traduzida(self, self.numero_do_tombamento , atributo_falho, coluna)
			else
				raise e
			end
		end
  end

  def to_sim_bens_por_unidade(data_referencia)
    # agente = self.localizacao_atual.agente_publico_municipal
    agente = self.unidade_gestora.gestor_no_periodo(data_referencia.end_of_month)
    uo = unidade_orcamentaria(self.unidade_gestora_id, data_referencia.year)

    begin
			texto = ""
			texto << "981".sim_preenche(3) + "," #1
			texto << Configuracao.first.codigo_do_municipio_no_tcm.sim_preenche(3) + "," #2
      texto << tombamento_to_sim(uo.id).sim_limite(20) + "," #3
      texto << self.localizacao_atual.data_de_inicio_na_localizacao.sim_data + "," #4
      texto << data_referencia.sim_data.first(6) + "," #5
      texto << data_referencia.sim_data.first(4) + '00' + "," #6
      texto << self.recebimento_de_bem.unidade_orcamentaria.orgao.codigo.sim_preenche(2) + "," #7
      texto << self.recebimento_de_bem.unidade_orcamentaria.codigo.codigo_uo_to_sim + "," #8
      texto << agente.cpf.sim_limite(11) + "," #9
      texto << agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).to_s.sim_preenche(1) + "," #10
      texto << agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).to_s.sim_preenche(1) + "," #11
      texto << agente.numero_da_portaria.to_s.sim_limite(10) #12
      # texto << (agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).present? ? agente.read_attribute_before_type_cast(:ingresso_sistema_publico_municipal).to_s : "N").sim_preenche(1) + "," #10
      # texto << (agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).present? ? agente.read_attribute_before_type_cast(:tipo_relacao_servico_publico).to_s : "E").sim_preenche(1) + "," #11
      # texto << (agente.numero_da_portaria.to_s == '' ? 'PORTARIA' : agente.numero_da_portaria.to_s).sim_limite(10) #12

      return texto
		rescue => e
			if e.class.to_s == "NoMethodError"
				atributo_falho = e.message.split(" ")[2]
				coluna = CSV.parse(texto, :headers => false).last.count
				raise e.mensagem_traduzida(self, self.numero_do_tombamento , atributo_falho, coluna)
			else
				raise e
			end
		end
  end

  def to_sim_bens_por_empenho(data_referencia)
    empenho = self.recebimento_de_material.ordem_de_compra.empenho
    uo = empenho.unidade_orcamentaria
    begin
			texto = ""
			texto << "983".sim_preenche(3) + "," #1
			texto << Configuracao.first.codigo_do_municipio_no_tcm.sim_preenche(3) + "," #2
      texto << tombamento_to_sim(uo.id).sim_limite(20) + "," #3
      texto << empenho.data_do_empenho.year.to_s + '00' + "," #4
      texto << uo.orgao.codigo.sim_preenche(2) + "," #5
      texto << uo.codigo.codigo_uo_to_sim + "," #6
      texto << empenho.data_do_empenho.sim_data + "," #7
      texto << empenho.numero_do_empenho.sim_limite(8) + "," #8
      texto << data_referencia.sim_data.first(6) #9

      return texto
		rescue => e
			if e.class.to_s == "NoMethodError"
				atributo_falho = e.message.split(" ")[2]
				coluna = CSV.parse(texto, :headers => false).last.count
				raise e.mensagem_traduzida(self, self.numero_do_tombamento , atributo_falho, coluna)
			else
				raise e
			end
		end
  end

  # Ajustes de Bens com dados faltantes
  def gera_responsaveis_faltantes
    self.localizacoes_dos_bens.order(data_de_inicio_na_localizacao: :asc).each do |local|
      centro_de_custo = Controladoria::CentroDeCusto.find_by(id: local.centro_de_custo_id)
      responsavel = centro_de_custo.responsavel_no_periodo_a_partir(local.data_de_inicio_na_localizacao)
      if responsavel.nil?
        centro_de_custo_mae = Controladoria::CentroDeCusto.find(centro_de_custo.centro_de_custos_mae_id)
        responsavel = centro_de_custo_mae.responsavel_do_centro_de_custos
      end

      responsavel_do_bem = Patrimonio::ResponsavelDoBemPatrimonial.create!(
        bem_patrimonial_id: self.id,
        pessoa_id: responsavel.agente_publico_municipal.pessoa.id,
        data_inicio: self.data_do_tombamento,
        tipo_de_responsavel: centro_de_custo_mae.present? ? 2 : 1
      )
    end
  end

  def unicidade_de_bem_por_item(requisicao)
    bens_patrimoniais = Patrimonio::BemPatrimonialDaRequisicao.joins(:item_da_requisicao_patrimonial).where('patrimonio_itens_da_requisicao_patrimonial.requisicao_patrimonial_id = ? and bem_id =  ?', requisicao.to_i, self.id)

    if bens_patrimoniais.present?
      return "Este bem patrimonial já está cadastrada nessa requisição."
    end
  end
end