MpWeixin

require 'rubygems'
require 'bundler'

Bundler.require

# require 'mp_weixin'

run MpWeixin::Server
# rackup config.ru

# initalize and get new access_token
client = MpWeixin::Client.new
client.get_token
# initalize with exists access_token
token_hash = {"expires_in" => "7200", "access_token" => access_token}
client = MpWeixin::Client.from_hash(token_hash)

client.menu.get_menus
# more detail check 'spec/mp_weixin/interface/'

# encoding: utf-8
class WechatClient
  include Mongoid::Document
  include Mongoid::Timestamps

  field :access_token, type: String
  field :expires_at, type: Integer

  class << self
    attr_accessor :wechat_client

    def get_access_token
      wechat_client = self.first || self.new

      {
        access_token: wechat_client.access_token,
        expires_at: wechat_client.expires_at.try(:to_i)
      }.keep_if{|_, v| v.present?}
    end
    def set_access_token(access_token, expires_at)
      wechat_client = self.first || self.new

      wechat_client.update_attributes(
                                             access_token: access_token,
                                             expires_at: expires_at
                                           )
    end

    # return an instance of MpWeixin#client with 'is_authorized?' is true
    #
    # client = WechatClient.this_client
    # client.message.custom_send(touser: "ozIMPt8wb8I8iYm-IjD1DHP-IQ9s", msgtype: "text", text: {content: "hey, we found you!"})
    def this_client
      unless @wechat_client.try("is_authorized?")
        @wechat_client = fresh_client
      end

      @wechat_client
    end

    def fresh_client
      token_hash = WechatClient.get_access_token
      expires_at_time = Time.at(token_hash[:expires_at]) rescue 2.hours.from_now

      if token_hash[:access_token].present? and (expires_at_time > Time.now)
        client = MpWeixin::Client.from_hash(token_hash)
      else
        client = MpWeixin::Client.new
        client.get_token

        WechatClient.set_access_token(client.token.token, client.token.expires_at)
      end

      client
    end
  end
end

# /app/services/wechat/response_rule.rb
# encoding: utf-8
module ResponseRule
  # handle corrent data post from weixin
  #
  # please @rewrite me
  def handle_message(request, message)
    #
    logger.info "Hey, one request from '#{request.url}' been detected, and content is #{message.as_json}"
    # did you want save this message ???
  end

  def response_text_message(request, message)
    case message.Content
      when /greet/
        reply_message = message.reply_text_message({Content: "whosyourdaddy!"})
        logger.info "response with #{reply_message.to_xml}"
      else
        reply_message = message.reply_text_message({Content: "hey, guy you are welcome!"})
        logger.info "response with #{reply_message.to_xml}"
    end
  end

  # 发送被动响应消息'
  #
  # please @rewrite me
  #
  #
  # can rely with instance of those class eg, TextReplyMessage, ImageReplyMessage, VoiceReplyMessage
  # VideoReplyMessage, MusicReplyMessage, NewsReplyMessage
  # quickly generate reply content through call 'reply_#{msg_type}_message(attributes).to_xml' @see 'spec/mp_weixin/server_helper_spec.rb'
  #
  def response_message(request, message, &block)
    if block_given?
      block.call(request, message)
    end
    send("response_#{message.MsgType}_message", request, message)

    # reply with
    # reply_#{msg_type}_message(attributes).to_xml
  end
end

# load custom response_rule
class MpWeixin::Server
  helpers ResponseRule
end

# routes.rb
Gxservice::Application.routes.draw do
  require "mp_weixin"
  require "#{Rails.root}/app/services/wechat/response_rule"
  mount MpWeixin::Server, :at => '/weixin'
end