require 'json'
require 'ostruct'

class WhoisParser

    def parse(data, whois_lookup, url)

      @parsed_data = Hash.new

      domain_type = url.split(".").last

      # check if the domain is registered
      if data["registered?"] == nil
        if check_domain_availability(data, whois_lookup)
          data["registered?"] = true
          data["available?"] = false
        else
          data["registered?"] = false
          data["available?"] = true
        end
      end

      if data["registered?"]
        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?"]
      # Parsed whois lookup data
      #@parsed_data["whois_lookup"] = data
      # Raw whois lookup data
      #@parsed_data["raw"] = whois_lookup.to_s

      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")
      if data.class == Array
        if data.first.class == Array
          clean_data = data.first.first.split(split_char).first.strip
        else
          clean_data = data.first.split(split_char).first.strip
        end
      else
        clean_data = data.split(split_char).first.strip
      end
      return clean_data
    end

    def check_domain_availability(data, whois_lookup)
      data1 = whois_lookup.to_s.scan(/No\smatch\sfor/).first
      data2 = whois_lookup.to_s.scan(/domain\snot\sfound/).first
      if data1 == nil || data2 == nil
        return true
      else
        return false
      end
    end

end