require 'imperituroard/projects/iot/internal_functions'

class Sksk_1

  attr_accessor :sk_url, :sk_url_broadcast, :sk_login, :sk_password, :internal_func

  def initialize(sk_url, sk_login, sk_password, sk_url_broadcast)
    @sk_url = sk_url
    @sk_login = sk_login
    @sk_password = sk_password
    @internal_func = InternalFunc.new
    @sk_url_broadcast = sk_url_broadcast
  end


  def sk_send_sms_one(msisdn, callback_url, text, alphaname)

    input_params = {:msisdn => msisdn, :callback_url => callback_url, :text => text, :alphaname => alphaname}
    output_params = {}
    request_message = {}

    begin
      uri = URI(sk_url)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl=true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      request_message = {
          "phone_number": msisdn,
          "extra_id": "4232j4h89932kjhs",
          "callback_url": callback_url,
          #"start_time": "2019-08-16 09:59:10",
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "sms"
          ],
          "channel_options": {
              "sms": {
                  "text": text,
                  "alpha_name": alphaname,
                  "ttl": 600
              }
          }
      }

      req.body = request_message.to_json
      res = https.request(req)
      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_sms_one: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}
      p res.body

    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_sms_one: Something wrong", :body => {:request_message => request_message}}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_one"}, "debug")
    output_params
  end


  def sk_send_viber_one(msisdn, callback_url, text)

    input_params = {:msisdn => msisdn, :callback_url => callback_url, :text => text}
    output_params = {}
    request_message = {}

    begin

      uri = URI(sk_url)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl=true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      request_message = {
          "phone_number": msisdn,
          "extra_id": "4232j4h89932kjhs",
          "callback_url": callback_url,
          #"start_time": "2019-08-16 09:59:10",
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "viber"
          ],
          "channel_options": {
              "viber": {
                  "text": text,
                  "ttl": 60,
                  # "img": "http://olddogs.org/logo.png",
                  # "caption": "Old Dogs need you!",
                  # "action": "http://olddogs.org",
              },
          }
      }
      req.body = request_message.to_json
      res = https.request(req)
      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_viber_one: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}

    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_one: Something wrong"}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_one"}, "debug")
    output_params
  end

  def sk_send_viber_sms_one(msisdn, callback_url, sms_text, viber_txt, alphaname)

    input_params = {:msisdn => msisdn, :callback_url => callback_url, :sms_text => sms_text, :viber_txt => viber_txt, :alphaname => alphaname}
    output_params = {}
    request_message = {}

    begin

      uri = URI(sk_url)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl=true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      request_message = {
          "phone_number": msisdn,
          "extra_id": "4232j4h89932kjhs",
          "callback_url": callback_url,
          #"start_time": "2019-08-16 09:59:10",
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "viber",
              "sms"
          ],
          "channel_options": {
              "sms": {
                  "text": sms_text,
                  "alpha_name": alphaname,
                  "ttl": 600
              },
              "viber": {
                  "text": viber_txt,
                  "ttl": 60,
                  # "img": "http://olddogs.org/logo.png",
                  # "caption": "Old Dogs need you!",
                  # "action": "http://olddogs.org",
              },
          }
      }

      req.body = request_message.to_json
      res = https.request(req)

      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_viber_sms_one: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}

    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_sms_one: Something wrong"}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_sms_one"}, "debug")
    output_params

  end


  def sk_send_sms_list(msisdn_list, callback_url, text, alphaname)

    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text, :alphaname => alphaname}
    output_params = {}
    request_message = {}

    begin
      uri = URI(sk_url_broadcast)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl = true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
      request_message = {
          "recipients": msisdn_list,
          "callback_url": callback_url,
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "sms"
          ],
          "channel_options": {
              "sms": {
                  "alpha_name": alphaname,
                  "text": text,
                  "ttl": 60
              }
          }
      }

      p request_message

      req.body = request_message.to_json
      res = https.request(req)

      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_sms_list: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}
    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_sms_list: Something wrong"}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_sms_list"}, "debug")
    output_params
  end


  def sk_send_viber_list(msisdn_list, callback_url, text)

    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text}
    output_params = {}
    request_message = {}

    begin
      uri = URI(sk_url_broadcast)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl = true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
      request_message = {
          "recipients": msisdn_list,
          "callback_url": callback_url,
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "viber"
          ],
          "channel_options": {
              "viber": {
                  "text": text,
                  "ttl": 60
              }
          }
      }

      p request_message

      req.body = request_message.to_json
      res = https.request(req)

      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_viber_list: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}
    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_list: Something wrong"}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_list"}, "debug")
    output_params
  end


  def sk_send_viber_sms_list(msisdn_list, callback_url, text, alphaname)

    input_params = {:msisdn_list => msisdn_list, :callback_url => callback_url, :text => text, :alphaname => alphaname}
    output_params = {}
    request_message = {}

    begin
      uri = URI(sk_url_broadcast)
      #8 - client id

      https = Net::HTTP.new(uri.host, uri.port)
      https.use_ssl = true
      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
      req = Net::HTTP::Post.new(uri.path, initheader = {:"Content-Type" => 'application/json'})

      req.basic_auth sk_login, sk_password

      # [{"phone_number": 375298766719}, {"phone_number": 375295730878}]
      request_message = {
          "recipients": msisdn_list,
          "callback_url": callback_url,
          "tag": "Dabrab_custom_api_1",
          "channels": [
              "viber",
              "sms"
          ],
          "channel_options": {
              "sms": {
                  "alpha_name": alphaname,
                  "text": text,
                  "ttl": 60
              },
              "viber": {
                  "text": text,
                  "ttl": 60
              }
          }
      }


      p request_message

      req.body = request_message.to_json
      res = https.request(req)

      output_params = {:code => 200,
                       :result => "Sksk_1.sk_send_viber_sms_list: Request processed",
                       :body => {:request_message => request_message,
                                 :res_code => res.code,
                                 :res_body => JSON.parse(res.body.to_s)}}
    rescue
      output_params = {:code => 500, :result => "Sksk_1.sk_send_viber_sms_list: Something wrong"}
    end
    internal_func.printer_texter({:input => input_params, :output => output_params, :procedure => "Sksk_1.sk_send_viber_sms_list"}, "debug")
    output_params
  end


end