require 'imperituroard/platforms/public/telegram'

require 'simpleidn'
require 'net/scp'
require 'net/ssh'
require 'ipaddr'
require 'net/http'
require 'json'
require 'date'



class Ukaz60Dns_2


  attr_accessor :telegram_messanger,
                :work_directory,
                :filename_blocked,
                :filename_tmp_blocked,
                :ip_for_redirect,
                :add_bl_memory_script,
                :del_bl_memory_script,
                :dns_login,
                :dns_password,
                :belgim_login,
                :belgim_password,
                :belgim_url,
                :blo,
                :unblo

  def initialize(telegram_api_url,
                 telegram_chat_id,
                 work_directory,
                 filename_blocked,
                 filename_tmp_blocked,
                 ip_for_redirect,
                 add_bl_memory_script,
                 del_bl_memory_script,
                 dns_login,
                 dns_password,
                 belgim_login,
                 belgim_password,
                 belgim_url
  )
    @telegram_messanger = Telegram_2.new(telegram_api_url, telegram_chat_id)
    @work_directory = work_directory
    @filename_blocked = filename_blocked
    @filename_tmp_blocked = filename_tmp_blocked
    @ip_for_redirect = ip_for_redirect
    @add_bl_memory_script = add_bl_memory_script
    @del_bl_memory_script = del_bl_memory_script
    @blo = 0
    @unblo = 0
  end

=begin


  def gen_mem_script()

    string = File.open(filename_blocked, 'r'){ |file| file.read }
    redns = /local-zone: "(.+)" redirect/
    m111 = string.scan(redns)

    string = File.open(filename_tmp_blocked, 'r'){ |file| file.read }
    m222 = string.scan(redns)


    old = []
    new = []
    diff = []
    diff2 = []

    for iii in m111
      new.push(iii[0])
    end

    for jjj in m222
      old.push(jjj[0])
    end

    def difference(other)
      h = other.each_with_object(Hash.new(0)) { |e,h| h[e] += 1 }
      reject { |e| h[e] > 0 && h[e] -= 1 }
    end

    for dfdfd in new
      if old.include?(dfdfd)
      else
        diff.push(dfdfd)
      end
    end

    for dfdfd2 in old
      if new.include?(dfdfd2)
      else
        diff2.push(dfdfd2)
      end
    end

    file = File.open(add_bl_memory_script, "w")
    for j in diff
      a111 = 'unbound-control local_data ' + j + " A #{ip_for_redirect}"
      a222 = 'unbound-control local_zone ' + j + ' redirect'
      #print a1
      file.puts(a111)
      file.puts(a222)
    end
    file.close

    file2 = File.open(del_bl_memory_script, "w")
    for j in diff2
      b111 = 'unbound-control local_zone_remove ' + j
      b222 = 'unbound-control local_data_remove ' + j
      #print a1
      file2.puts(b111)
      file2.puts(b222)
    end
    file2.close

    p diff
    p diff2


    if diff != [] && @blo == 0
      telegram_messanger.telegram_message("Domains for blocking: " + diff.to_s)
      @blo = 1
    end

    if diff2 != [] && @unblo == 0
      telegram_messanger.telegram_message("Domains for unblocking: " + diff2.to_s)
      @unblo = 1
    end


    if diff == [] && diff2 == []
      "compared"
    else
      "mismatch"
    end

  end






    stringnunblo = File.open('/scripts/ruby/dns/nonblocked.conf', 'r'){ |file| file.read }
    noblocked =  stringnunblo.split("\n")

    m2 = m2 - noblocked


    stringnunblo2 = File.open('/scripts/ruby/dns/manualblocked.conf', 'r'){ |file| file.read }
    manualblocked =  stringnunblo2.split("\n")

    m2 = m2 + manualblocked
    m2 = m2.uniq

    numblocked = m2.length
    manualblockedlen = manualblocked.length
    numblwithoutexcluded = m2.length
    numnoblocked = noblocked.length


    results.update({"numblocked" => numblocked, "numblwithoutexcluded"=>numblwithoutexcluded, "numnoblocked"=>numnoblocked, "manualblocked"=>manualblockedlen})

    File.delete("blocked.conf") if File.exist?("blocked.conf")
    File.delete("blocked_old.conf") if File.exist?("blocked_old.conf")

    file = File.open("blocked.conf", "w")
    for j in m2
      a1 = 'local-zone: "' + j + '." redirect'
      a2 = "local-data: \"" + j + ". IN A \"#{ip_for_redirect}\""
      #print a1
      file.puts(a1)
      file.puts(a2)
    end
    file.close

    dnses = [
        "172.30.159.67",
        "172.30.159.68",
        "172.30.161.145",
        "172.30.161.146",
        "172.29.253.33",
        "172.29.253.34",
        "172.28.240.33",
        "172.28.240.34",
        "172.27.234.33",
        "172.27.234.34",
        "172.26.253.33",
        "172.26.253.34",
        "172.25.225.51",
        "172.25.225.52",
        "172.24.214.130",
        "172.24.247.155",
        "172.24.247.157"
    ]

    dnsnamess = {
        "172.30.159.67" => "min26dns1",
        "172.30.159.68" => "min26dns2",
        "172.30.161.145" => "min26dns3",
        "172.30.161.146" => "min26dns4",
        "172.29.253.33" => "gro26dns1",
        "172.29.253.34" => "gro26dns2",
        "172.28.240.33" => "bre26dns1",
        "172.28.240.34" => "bre26dns2",
        "172.27.234.33" => "gom26dns1",
        "172.27.234.34" => "gom26dns2",
        "172.26.253.33" => "mog26dns1",
        "172.26.253.34" => "mog26dns2",
        "172.25.225.51" => "vit26dns1",
        "172.25.225.52" => "vit26dns2",
        "172.24.214.130" => "minsrv1",
        "172.24.247.155" => "minsrv2",
        "172.24.247.157" => "minsrv3"
    }



    for fa in dnses

      Net::SCP.download!(fa, dns_login,
                         "/usr/local/etc/unbound/blocked.conf", "blocked_old.conf",
                         :ssh => { :password => dns_password })

      ressss = gen_mem_script

      if ressss == "mismatch"
        Net::SCP.upload!(fa, dns_login,
                         "blocked.conf", "/usr/local/etc/unbound/blocked.conf",
                         :ssh => { :password => dns_password })

        results.update({dnsnamess[fa] => "updated"})

        Net::SCP.upload!(fa, dns_login,
                         "add_bl_memory.sh", "/tmp/add_bl_memory.sh",
                         :ssh => { :password => dns_password })

        Net::SCP.upload!(fa, dns_login,
                         "del_bl_memory.sh", "/tmp/del_bl_memory.sh",
                         :ssh => { :password => dns_password })

        Net::SSH.start(fa, dns_login, :password => dns_password) do |ssh|
          sleep 4
          result = ssh.exec!("sh /tmp/add_bl_memory.sh")
          result2 = ssh.exec!("sh /tmp/del_bl_memory.sh")
          #puts resul
          #results.update({fa+"_stat" => result+"_"+result2})
        end

      else
        results.update({dnsnamess[fa] => "compared"})
      end

    end

    p results
    p m2

    endtime =DateTime.now

    results.update({"scriptstart"=>starttime.to_s, "scriptend"=>endtime.to_s})

    telegram_messanger.telegram_message(results.to_s)

=end

#File.delete("blocked.conf") if File.exist?("blocked.conf")
#File.delete("blocked_old.conf") if File.exist?("blocked_old.conf")
#File.delete("add_bl_memory.sh") if File.exist?("add_bl_memory.sh")



end