require 'json'
require 'ostruct'

class WhoisParser

    def parse(data, whois_lookup, url, raw, dev)

      @parsed_data = Hash.new

      # check if the domain is registered
      data = check_domain_availability(data, whois_lookup)

      if data["registered?"] && !dev
        domain_type = url.split(".").last
        case domain_type
        when "br"
          parserBr(data, whois_lookup, url)
        when "network"
          parserNetwork(data, whois_lookup, url)
        else
          parserCom(data, whois_lookup, url)
        end

      else
        # Domain
        @parsed_data["domain"] = url
      end

      # Registered?
      @parsed_data["registered?"] = data["registered?"]
      # Available?
      @parsed_data["available?"] = data["available?"]

      if raw
        # Parsed whois lookup data
        @parsed_data["whois_lookup"] = data
        # Raw whois lookup data
        @parsed_data["raw"] = whois_lookup.to_s
      end

      return JSON.pretty_generate(@parsed_data)
    end

    def parserCom(data, whois_lookup, url)
      # Domain Name
      if data["domain"] != nil
        @parsed_data["domain"] = data["domain"]
      else
        @parsed_data["domain"] = url
      end
      # Owner
      owner_data = whois_lookup.to_s.scan(/Registrant\sName:\s([^\\]+)/).first
      @parsed_data["owner"] = spliter(owner_data, "\r").downcase.split.map(&:capitalize).join(' ')
      # Registrar
      @parsed_data["registrar"] = data["registrar"][:name]
      # Creation Date
      temp = whois_lookup.to_s.scan(/Creation\sDate:\s([^\\]+)/).first.first
      creation_date_data = temp.scan(/Creation\sDate:\s([^\\]+)/).last
      @parsed_data["created_on"] = spliter(creation_date_data, "\n")
      # Expiration Date
      temp = whois_lookup.to_s.scan(/Expiration\sDate:\s([^\\]+)/).first.first
      expiration_date_data = temp.scan(/Expiration\sDate:\s([^\\]+)/).last
      @parsed_data["expires_on"] = spliter(expiration_date_data, "\n")
      # Update Date
      @parsed_data["update_on"] = data["updated_on"]
    end

    def parserBr(data, whois_lookup, url)
      # Domain Name
      domain_data = whois_lookup.to_s.scan(/domain:\s([^\\]+)/)
      if domain_data.class == Array
        if domain_data.first.class == Array
          domain = domain_data.first.first.split("\r").first.strip
        else
          domain = domain_data.first.split("\r").first.strip
        end
      else
        domain = domain_data.split("\r").first.strip
      end
      if domain != ""
        @parsed_data["domain"] = domain
      else
        @parsed_data["domain"] = url
      end
      # Owner
      owner_data = whois_lookup.to_s.scan(/owner:\s([^\\]+)/).first
      @parsed_data["owner"] = spliter(owner_data, "\r").force_encoding("ISO-8859-1").encode("UTF-8")
      # Registrar
      @parsed_data["registrar"] = "Registro BR"
      # Creation Date
      @parsed_data["created_on"] = data["created_on"]
      # Expiration Date
      @parsed_data["expires_on"] = data["expires_on"]
      # Update Date
      @parsed_data["updated_on"] = data["updated_on"]
    end

    def parserNetwork(data, whois_lookup, url)
      # Domain Name
      domain_data = whois_lookup.to_s.scan(/Domain\sName:\s([^\\]+)/)
      if domain_data.class == Array
        if domain_data.first.class == Array
          domain = domain_data.first.first.split("\r").first.strip
        else
          domain = domain_data.first.split("\r").first.strip
        end
      else
        domain = domain_data.split("\r").first.strip
      end
      if domain != ""
        @parsed_data["domain"] = domain
      else
        @parsed_data["domain"] = url
      end
      # Owner
      owner_data = whois_lookup.to_s.scan(/Registrant\sName:\s([^\\]+)/).first
      @parsed_data["owner"] = spliter(owner_data, "\r")
      # Registrar
      registrar_data = whois_lookup.to_s.scan(/Registrar:\s([^\\]+)/)
      @parsed_data["registrar"] = spliter(registrar_data)
      # Creation Date
      creation_date_data = whois_lookup.to_s.scan(/Creation\sDate:\s([^\\]+)/).first
      @parsed_data["created_on"] = spliter(creation_date_data, "\n")
      # Expiration Date
      expiration_date_data = whois_lookup.to_s.scan(/Expiry\sDate:\s([^\\]+)/).first
      @parsed_data["expires_on"] = spliter(expiration_date_data, "\n")
      # Update Date
      update_date_data = whois_lookup.to_s.scan(/Last\supdate\sof\sWHOIS\sdatabase:\s([^\\]+)/).first
      @parsed_data["update_on"] = spliter(update_date_data, "<")
    end

    def spliter(data, split_char = "\r")
      clean_data = ""
      if data != nil
        if data.class == Array
          if data.first.class == Array
            if data.first.first != nil
              clean_data = data.first.first.split(split_char).first.strip
            end
          else
            if data.first != nil
              clean_data = data.first.split(split_char).first.strip
            end
          end
        else
          clean_data = data.split(split_char).first.strip
        end
      end
      return clean_data
    end

    def check_domain_availability(data, whois_lookup)
      data1 = whois_lookup.to_s.scan(/(No\smatch\sfor\s)/i).first
      data2 = whois_lookup.to_s.scan(/(domain\snot\sfound)/i).first
      data3 = whois_lookup.to_s.scan(/(release\sprocess:\swaiting)/i).first
      if data3 != nil
        data["registered?"] = false
        data["available?"] = false
      elsif data1 == nil && data2 == nil
        data["registered?"] = true
        data["available?"] = false
      else
        data["registered?"] = false
        data["available?"] = true
      end
      return data
    end

end