# == Schema Information
#
# Table name: uplinks
#
#  id                      :integer          not null, primary key
#  router_inventory_id     :integer
#  wl_association          :string(255)
#  wds_enabled             :boolean          default(FALSE)
#  wl_wpa_key              :string(255)
#  wl_band                 :string(255)
#  wl_ssid_name            :string(255)
#  wl_ssid_uniqe_id        :integer
#  mo_service              :string(255)
#  mo_apn                  :string(255)
#  mo_device               :string(255)
#  mo_username             :string(255)
#  mo_password             :string(255)
#  ip_type                 :string(255)
#  ip                      :string(255)
#  subnet_mask             :string(255)
#  gateway                 :string(255)
#  uplink_type             :string(255)      default("1")
#  primary_dns             :string(255)
#  secondary_dns           :string(255)
#  created_at              :datetime
#  updated_at              :datetime
#  load_balance_percentage :integer          default(0)
#  is_primary              :boolean          default(FALSE)
#  uplink_name             :string(255)
#  mo_proto_key            :string(255)
#  mo_is_advanced          :boolean          default(FALSE)
#

class Uplink < ActiveRecord::Base
  belongs_to :router_inventory
  include PublicActivity::Model
  serialize :mwan3_cfg, Hash
  tracked owner: ->(controller, model) { controller && controller.tracked_current_user },params:
  { :attributes => proc {|controller, model_instance| {"uplink(#{model_instance.uplink_name})" => model_instance.changes}}},organisation_id: ->(controller, model) { (controller && controller.tracked_current_user) ? controller.tracked_current_user.organisation_id : model.router_inventory.organisation_id }, :location_network_id => proc {|controller, model_instance| model_instance.router_inventory.location_network_id }
  
  tracked assumed_by: proc {|controller, model| controller.user_assumed_by if controller}

  default_scope { where(is_deleted: false) }
  after_destroy do |u|
    self.router_inventory.update_redis
  end

  before_save :save_dns_mode

  def self.check_activity_perission
    Uplink.public_activity_off
  end

  def save_dns_mode
    if self.ip_type == "static"
    	self.dns_mode = "custom"
    end
    if self.uplink_type == "2"
      self.wds_enabled = true
    end
  end

  def esim_eid_request(imsi) 
    retrun if imsi.blank?
    path = "/data-consumption?limit=2&operationalImsi=#{imsi}&" 
    response = get_sims_common_request_appending("GET", path, {})
    $redis.set "EID_#{response}", self.id
  end

  def self.esim_eid_response(requestid) 
    Uplink.public_activity_off
    response = get_sims_common_response_appending(requestid)
    return if response.blank? || response["entries"].blank?
    eid, res_imsi = response["entries"].map{|x| [x["eid"],x["operationalImsi"]] }.first 
    uplinkid = $redis.get "EID_#{requestid}" 
    return if uplinkid.blank?
    $redis.del "EID_#{requestid}"
    upl = Uplink.where(:id => uplinkid.to_i).first
    return if upl.eid == eid
    upl.eid = eid
    upl.save!
  end

  def get_sims_common_request_appending(method, path, params)
    url = URI(APPLICATION['defaults']['teal_sim_url'] + path + APPLICATION['defaults']['callback_url'])
    http = Net::HTTP.new(url.host, url.port)
    requestid = (Time.now.to_f * 1000).to_i + rand(500)
    Rails.logger.info("----{{{{{{{{{{{{{{{{{{{{{{{{{{{----------------------#{requestid}-----------------#{url}-------- #{params}")
    http.use_ssl = true
    if method == 'GET'
        request = Net::HTTP::Get.new(url)
    elsif method == 'POST'
        request = Net::HTTP::Post.new(url)
        request.body = params.to_json
    end
    request["content-type"] = 'application/json'
    request['RequestID'] = requestid
    request['ApiKey'] = APPLICATION['defaults']['APIKEY']
    request['ApiSecret'] = APPLICATION['defaults']['APISECRET']
    response = http.request(request)
    Rails.logger.info("----response000000----#{requestid} ----- #{response.body}")
    return requestid
  end

  def self.get_sims_common_response_appending(requestid)
    url = URI.parse(APPLICATION['defaults']['res_url'])
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true
    request = Net::HTTP::Get.new(url)
    request["content-type"] = 'application/json'
    request['RequestID'] = requestid
    request['ApiKey'] = APPLICATION['defaults']['APIKEY']
    request['ApiSecret'] = APPLICATION['defaults']['APISECRET']
    response = http.request(request)
    Rails.logger.info("----response11111----#{requestid} ---- #{response.body}")
    return nil if response.body.blank?
    return JSON.parse(response.body)
  end

  def mwan3_config_applicable?
    self.mo_is_advanced && self.is_primary && (self.uplink_type == "1") && self.mwan3_cfg.present? && self.mwan3_cfg["up_count"].present? && self.mwan3_cfg["down_count"].present?
  end

  def mwan3_config_hsh
    return {"INT" => "5", "UP" => self.mwan3_cfg["up_count"], "DN" => self.mwan3_cfg["down_count"], "FL_CCT" => 1, "FL_DCT" => 0, "T_IP1" => "8.8.8.8", "T_IP2" => "208.67.222.222", "CQ" => 0, "CQ_FL" => self.mwan3_cfg["failure_latency"], "CQ_RL" => self.mwan3_cfg["recovery_latency"]}
  end

  def set_custom_dns(dns_ips)
    self.dns_mode = "2"
    dn_ips = dns_ips.split(",")
    self.primary_dns = dn_ips[0]
    self.secondary_dns = dn_ips[1]
  end

  def set_custom_failover_settings(failoverback)
    fob = failoverback.split(",")
    self.mo_is_advanced = "1"
    self.mwan3_cfg["down_count"] = fob[0]
    self.mwan3_cfg["up_count"] = fob[1]
  end 
end