class Quantarium::Quantarium
  include QuantariumConstants
  MAIN_URL = 'https://qvmservices.xome.com/QDataService/'
  USER = Rails.application.secrets.quantarium_user_id
  KEY = Rails.application.secrets.quantarium_key

  def initialize(geo, address, user, unit = nil)
    @geo = geo
    @address = address
    @unit = unit
    @user = user
  end

  # {'QueryPropertiesByAddress' => {user, key, address, citystate_zip}}
  # {'GetPropertyRecords' => {user, key, property_id, records[all, alllistings]}}
  # {'GetListingRecords' => {user, key, org_id, listing_id, records[basic, extended, “basic, extended”]}}
  def perform
    result = {}

    property = get_property

    @user.log_call 'Quantarium'
    return property[:error] if property[:error].present?
    return 'No data for given address.' if property['id'].nil?

    property_records = get_property_records(property['id'])
    property.delete('id')
    result['property'] = property
    result.merge!(property_records)
    result = delete_extra_params(result)
    result = translate_quantarium_data(result)
    ensure_all_keys_present(result)
  rescue Exception => e
    raise e if Rails.env == 'development'
    'Wrong address format'
  end

  private

  def get_property
    street = @geo[:address]
    citystate_zip = @geo[:zip]

    if @address.present?
      address = parse_user_address

      if address.present?
        street = address.to_s(:line1)
        citystate_zip = [address.postal_code, address.postal_code_ext].compact.join('-')
      end
    end

    street += " unit #{@unit}" if @unit.present?
    query = "QueryPropertiesByAddress?u=#{USER}&k=#{KEY}&address=#{street}&citystate_zip=#{citystate_zip}&hc=1"

    response = request(query).fetch(0, {})
  end

  def get_property_records(id)
    response = {}
    property_records = request("GetPropertyRecords?u=#{USER}&k=#{KEY}&id=#{id}&records=all")
    response['assessment'] = property_records['assessment']

    all_listings = request("GetPropertyRecords?u=#{USER}&k=#{KEY}&id=#{id}&records=alllistings")
    if all_listings['listings'].present?
      listing = all_listings['listings'][0]
      response['listing_record'] = listing
      if listing.is_a?(Hash) && listing['org_id'].present? && listing['listing_id'].present?
        listing_record = get_listing_records(listing['org_id'], listing['listing_id'])
        response['mls_listing_record_details'] = listing_record['details'] if listing_record['details']
        response['images'] =
          if listing_record['images'].present? && !listing_record['images']['urls'].empty?
            listing_record['images']['urls']
          else
            dig_images(all_listings['listings'])
          end
      end
    end

    response
  end

  def dig_images(all_listings)
    all_listings[1..-1].each do |listing|
      listing_record = get_listing_records(listing['org_id'], listing['listing_id'])
      if listing_record['images'].present? && !listing_record['images']['urls'].empty?
        return listing_record['images']['urls']
      end
    end
    []
  end

  def get_listing_records(org_id, listing_id)
    response = request("GetListingRecords?u=#{USER}&k=#{KEY}&org=#{org_id}&id=#{listing_id}")
    response
  end

  def request(url)
    link = URI.encode(MAIN_URL + url).gsub('+', '%2B')
    RestClient::SharedConfig.log_geodata(@geo, @address)
    Rails.logger.info("Quantarium request: #{link}")

    options = RestClient::SharedConfig.configure(link)
    JSON.parse(RestClient::Request.execute(options))
  rescue Exception => e
    raise e if Rails.env == 'development'
    {}
  end

  def translate_quantarium_data(result)
    {
      'ex_garage_features'              => GARAGE_TYPE_OR_PARKING,
      'ex_patio_yn'                     => YN,
      'Garage_Type'                     => GARAGE_TYPE_OR_PARKING,
      'if_basement_yn'                  => YN,
      'if_cooling_yn'                   => YN,
      'if_fireplace_yn'                 => YN,
      'if_levels'                       => IF_LEVELS_FEATURES,
      'if_security_system_yn'           => YN,
      'Owner_Occupied'                  => YN,
      'rm_family_yn'                    => YN,
      'rm_room11_features'              => RM_ROOMS,
      'rm_room11_type'                  => RM_ROOMS,
      'rm_room13_features'              => RM_ROOMS,
      'rm_room13_type'                  => RM_ROOMS,
      'School_Tax_District_1_Indicator' => SCHOOL_TAX_DISTRICT_INDICATOR,
      'School_Tax_District_2_Indicator' => SCHOOL_TAX_DISTRICT_INDICATOR,
      'School_Tax_District_3_Indicator' => SCHOOL_TAX_DISTRICT_INDICATOR,
    }.each do |key, value|
      translation_helper(result, key, value)
    end

    %w[
        ex_exterior_wall_features
        ex_general_features
        ex_patio_features
        ex_parking_features
        ex_construction_features
        ex_foundation_features
        ex_roof_features
        ex_sewer_features
        ex_style_features
        if_appliance_features
        if_basement_features
        if_cooling_features
        if_floor_features
        if_general_features
        if_heating_features
        if_levels_features
        if_security_features
        if_water_features
        in_property_type
        in_subtype
        LSale_Price_Code
        Main_Building_Area_Indicator
        Site_Influence
        use_code
    ].each do |key|
      translation_helper(result, key)
    end

    result
  end

  def delete_extra_params(result)
    result.each_key do |key|
      next if key == 'images'

      result[key].each_key do |embedded_key|
        result[key].delete(embedded_key) unless ALLOWED_PARAMS.keys.include?(embedded_key)
      end
    end

    result
  end

  def ensure_all_keys_present(result)
    ALLOWED_PARAMS.each do |k, v|
      next if k == 'id'
      if result[v]
        result[v][k] = nil unless result[v][k]
      end
    end

    ALLOWED_PARAMS.values.uniq.each do |value|
      result[value] = {} unless result[value]
    end

    result['images'] = [] unless result['images']

    result
  end

  def translation_helper(result, field, constant = nil)
    return if %w[if_levels Site_Influence].include? field

    constant ||= ('Quantarium::QuantariumConstants::' + field.upcase).constantize
    position_in_result = Quantarium::QuantariumConstants::ALLOWED_PARAMS[field]

    if result[position_in_result] && result[position_in_result][field]
      res = []

      result[position_in_result][field].split(',').each do |to_translate|
        res << constant[to_translate] unless constant[to_translate].nil?
      end

      result[position_in_result][field] = res.join(', ') unless res.blank?
    end
  end

  def parse_user_address
    user_address = StreetAddress::US.parse(@address)
    geo_address = StreetAddress::US.parse(
      (@geo.slice(:address, :city, :state, :zip).values + ['USA']).join(', ')
    )

    if user_address.nil? ||
       user_address.number != geo_address.number ||
       user_address.street != geo_address.street ||
       user_address.street_type != geo_address.street_type ||
       user_address.city != geo_address.city ||
       user_address.state != geo_address.state ||
       user_address.postal_code != geo_address.postal_code ||
       user_address.postal_code_ext != geo_address.postal_code_ext

      geo_address
    else
      user_address
    end
  end

end