#!/usr/bin/ruby

require 'net/http'
require 'cgi'
require 'json'

require_relative "Util"

module CloudmunchService
  include Util  

  ##################################################################################
  ###
  ### downloadKeys(filekey, context, contextid)
  ### deleteKeys()
  ### getCloudmunchData(paramHash)
  ### updateCloudmunchData(paramHash, method = "POST") 
  ### deleteCloudmunchData(paramHash)
  ### parseResponse(responseJson)
  ### generateServerURL(paramHash, appendQueryParams = nil)
  ###
  ###
  ################################################################################## 

  def downloadKeys(filekey, context, contextid)

    paramHash = Hash.new
    paramHash["context"]     = context
    paramHash["contextID"]   = contextid
    paramHash["file"]        = filekey

    keyString = getCloudmunchData(paramHash)
    
    if !keyString.to_s == ""
      log("ERROR", "downloaded key content is empty, please re-upload key and try")
      return nil
    end
    
    filename = "keyfile_" + Time.now.strftime('%Y%m%d%H%M%S%L')
    file     = @appContext.get_data("{workspace}")+"/"+filename
    
    File.open(file, 'w') { |file| file.write(keyString) }
    system('chmod 400 '+file)
    
    if @keyArray.nil?
      @keyArray = []
    end

    @keyArray.push(file)
    return file;
  end

  def deleteKeys()
    fileName = @appContext.get_data("{workspace}")+"/keyfile_*"
    File.delete(fileName)
  end

  def getCloudmunchData(paramHash)
    serverurl = nil
    serverurl = generateServerURL(paramHash,true)

    if serverurl.nil?
        log("DEBUG", "Unable to generate server url")
        log("ERROR", "Unable to get data from cloudmunch")    
        return nil
    end

    uri = URI.parse(serverurl)              
    
    log("DEBUG", "URI for get : ")
    log("DEBUG", uri)          
    
    responseJson = Net::HTTP.get(uri)
    
    parseResponse(responseJson)
  end

  def updateCloudmunchData(paramHash, method = "POST") 
      paramData = Hash.new
      paramData["data"] = paramHash["data"]
      
      serverurl = nil
      serverurl = generateServerURL(paramHash)

      if serverurl.nil?
          log("DEBUG", "Unable to generate server url")
          log("ERROR", "Unable to "+method+" data on cloudmunch")    
          return nil
      end

      uri = URI.parse(serverurl)              
      
      log("DEBUG", "URI for "+method+" : ")
      log("DEBUG", uri)          
      
      if method.casecmp("post") == 0
        responseJson = Net::HTTP.post_form(uri,"data" => paramData.to_json)
      elsif method.casecmp("patch") == 0
        #code for patch
      elsif method.casecmp("put") == 0
        #code for put
      end
      return parseResponse(responseJson.body)      
  end

  def deleteCloudmunchData(paramHash)
    paramContext = paramHash["context"]
    paramContextID = paramHash["contextID"]

    if !paramContext.nil? && !paramContext.empty? && !paramContextID.nil? && !paramContextID.empty?
        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+context+"/"+contextID;
        serverurl=serverurl+"?apikey="+@appContext.get_data("{api_key}")
        uri = URI.parse(serverurl)
        Net::HTTP::Delete(uri)
        return 1
    else
        return nil
    end
  end 

  def parseResponse(responseJson)
    begin
        JSON.parse(responseJson)
    rescue
        return responseJson
    end

    requestDetails = (JSON.load(responseJson))['request']
    responseData   = (JSON.load(responseJson))['data']

    log("DEBUG", "Response : ")
    log("DEBUG", responseJson)
    
    if !requestDetails['status'].nil? && requestDetails['status'].casecmp('success') == 0    
        return responseData
    else
        if !requestDetails['message'].nil?
          log("ERROR", requestDetails['message'])
        end
        return nil
    end
  end

  

  def generateServerURL(paramHash, appendQueryParams = nil)

    serverurl = ""
    
    if !paramHash["url"].nil?
        serverurl = @appContext.get_data("{master_url}")+"/"+paramHash["url"]
    elsif !paramHash["context"].nil?
        paramContext       = paramHash["context"].nil? ? nil : paramHash["context"]
        paramContextID     = paramHash["contextID"].nil? ? nil : paramHash["contextID"]
        paramSubContext    = paramHash["subContext"].nil? ? nil : paramHash["subContext"]
        paramSubContextID  = paramHash["subContextID"].nil? ? nil : paramHash["subContextID"]
        paramLeafContext   = paramHash["leafContext"].nil? ? nil : paramHash["leafContext"]
        paramLeafContextID = paramHash["leafContextID"].nil? ? nil : paramHash["leafContextID"]

        serverurl=@appContext.get_data("{master_url}")+"/applications/"+@appContext.get_data("{application}")+"/"+paramContext

        if !paramContextID.nil? && !paramContextID.empty?
            serverurl=serverurl+"/"+paramContextID;
            if !paramSubContext.nil? && !paramSubContext.empty?
                serverurl=serverurl+"/"+paramSubContext;              
                if !paramSubContextID.nil? && !paramSubContextID.empty?
                    serverurl=serverurl+"/"+paramSubContextID;
                    if !paramLeafContext.nil? && !paramLeafContext.empty?
                        serverurl=serverurl+"/"+paramLeafContext;
                        if !paramLeafContextID.nil? && !paramLeafContextID.empty?
                            serverurl=serverurl+"/"+paramLeafContextID;
                        end
                    end
                end
            end
        end
    else
        log("DEBUG", "No context provided for get api call");
        return nil
    end

    queryString = ""
    
    if !appendQueryParams.nil?
      queryString = queryString + "filter=" + paramHash["filter"].to_json + "&" if !paramHash["filter"].nil?
      queryString = queryString + "file="   + paramHash["file"].to_s      + "&" if !paramHash["file"].nil?
      queryString = queryString + "fields=" + paramHash["fields"].to_s    + "&" if !paramHash["fields"].nil?
      queryString = queryString + "count="  + paramHash["count"].to_s     + "&" if !paramHash["count"].nil?
      queryString = queryString + "offset=" + paramHash["offset"].to_s    + "&" if !paramHash["offset"].nil?
      queryString = queryString + "request_category=" + paramHash["requestCategory"].to_s + "&" if !paramHash["requestCategory"].nil?
      queryString = queryString + "order_by=" + paramHash["orderBy"].to_s + "&" if !paramHash["orderBy"].nil?
      queryString = queryString + "group_by=" + paramHash["groupBy"].to_s + "&" if !paramHash["groupBy"].nil?
    end
    serverurl = serverurl+"?"+queryString+"apikey="+@appContext.get_data("{api_key}")
    return serverurl
  end

  def self.putCustomDataContext(server, endpoint, param)
    result = self.http_post(server, endpoint, param)
    
    if result.code.to_s == "200"
      return true 
    else
      return false 
    end     
  end

  def self.getCustomDataContext(server, endpoint, param)
      return self.http_get(server, endpoint, param)
  end

  def self.http_get(server,path,params)
    if params.nil?
     return Net::HTTP.get(server, path)
    else
       queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
       puts ("SDKDEBUG: Calling URL " + server+queryStr)
       uri = URI(server + "/" + queryStr)
       return Net::HTTP.get(uri) 
    end
  end
 
  def self.http_post(server,path,params)
    queryStr =  "#{path}?".concat(params.collect { |k,v| "#{k}=#{CGI::escape(v.to_s)}" }.join('&'))
    puts ("SDKDEBUG: Calling URL " + server+queryStr)
    if params.nil?
        return Net::HTTP.post(server, path)
    else
        uri = URI(server +  path)
        return Net::HTTP.post_form(uri, params)
    end
  end

  # def self.getDataContext(server, endpoint, param)
  #     getCustomDataContext(server, endpoint, param)     
  # end

  # def self.updateDataContext(server, endpoint, param)
  #     putCustomDataContext(server, endpoint, param)  
  # end

  def getDataForContext(server, endpoint, param)
      getCustomDataContext(server, endpoint, param)    
  end

  def updateDataForContext(server, endpoint, param)
      putCustomDataContext(server, endpoint, param)  
  end
end