---
-- Using oauth in lua. ( for Corona version)
--
--              (original)
--     Copyright 2009-2010 by DracoBlue (JanS@DracoBlue.de)
--                 http://dracoblue.net 
--              
--              (for Corona version)
--              developed by Keisuke Kimura(@muxukeikei)
--              
-- @version 2.0
-- @license MIT License
--
-- version2.0
-- async http request support
-- fix some bug
--
--
 
module(...,package.seeall)
 
local crypto = require("crypto")
local mime = require("mime")
local http = require("socket.http")
local ltn12 = require("ltn12")
 
local function encode_parameter(str)
        return str:gsub('[^-%._~a-zA-Z0-9]',function(c)
                return string.format("%%%02x",c:byte()):upper()
        end)
end
 
local function sha1(str,key,binary)
        binary = binary or false
        return crypto.hmac(crypto.sha1,str,key,binary)
end
 
local function get_nonce()
        return mime.b64(crypto.hmac(crypto.sha1,tostring(math.random()) .. "random" .. tostring(os.time()),"keyyyy"))
end
 
local function get_timestamp()
        return tostring(os.time() + 1)
end
 
local function rawGetRequest(url,callback)
   
    if callback then
        
                network.request(url,"GET",callback,nil)
         
    else
   
                local r,c,h
                local response = {}
           
                r,c,h = http.request{
                        url = url,
                        sink = ltn12.sink.table(response)
                }
                
                return table.concat(response,""),r,c,h
  
    end
   
end
 
local function rawPostRequest(url, rawdata, callback)
    
        if callback then
                
                local params = {}
  
                params.header =  {
                        ["Content-Type"] = "application/x-www-form-urlencoded",
                        ["Content-Length"] = string.len(rawdata),
                }
                params.body = rawdata
   
                network.request(url,"POST",callback,params)
                
        else
        
                local r,c,h
                local response = {}
                
                r,c,h = http.request{
                        url = url,
                        method = "POST",
                        headers = {
                                ["Content-Type"] = "application/x-www-form-urlencoded",
                                ["Content-Length"] = string.len(rawdata),
                        },
                        source = ltn12.source.string(rawdata),
                        sink = ltn12.sink.table(response)
                }
                
                return table.concat(response,""),r,c,h
        
        end
    
end
 
local function oauth_sign(url, method, args, consumer_secret)
 
    assert(method == "GET" or method == "POST","method must be either POST or GET")
    assert(consumer_secret,"consumer_secret required")
    assert(url,"url required")
    
    local token_secret = args.oauth_token_secret or ""
 
    --
    -- Remove the token_secret from the args, 'cause we neither send nor sign it.
    -- (we use it for signing which is why we need it in the first place)
    --
    args.oauth_token_secret = nil
 
        local keys_and_values = {}
 
        for key, val in pairs(args) do
        table.insert(keys_and_values, {
          key = encode_parameter(key),
          val = encode_parameter(val)
        })
    end
 
    table.sort(keys_and_values, function(a,b)
        if a.key < b.key then
            return true
        elseif a.key > b.key then
            return false
        else
            return a.val < b.val
        end
    end)
    
    local key_value_pairs = {}
        for _, rec in pairs(keys_and_values) do
        table.insert(key_value_pairs, rec.key .. "=" .. rec.val)
        end
    
        local query_string_except_signature = table.concat(key_value_pairs, "&")
   
        local SignatureBaseString = method .. '&' .. encode_parameter(url) .. '&' .. encode_parameter(query_string_except_signature)
        local key = encode_parameter(consumer_secret) .. '&' .. encode_parameter(token_secret)
    
        local hmac_binary = sha1(SignatureBaseString, key, true)
 
        local hmac_b64 = mime.b64(hmac_binary)
   
        local query_string = query_string_except_signature .. '&oauth_signature=' .. encode_parameter(hmac_b64)
 
        if method == "GET" then
           return url .. "?" .. query_string
        else
                return query_string
        end
end
 
local function getRequestToken(options,method,callback)
 
    assert(options.authorize_url,"authorize_url option must be set") 
    assert(options.request_token_url,"request_token_url option must be set") 
    assert(options.consumer_key,"consumer_key option must be set")
    assert(options.consumer_secret,"consumer_secret option must be set")
    assert(options.token_ready_url,"token_ready_url option must be set")
        assert(method == "GET" or method == "POST","method must be either POST or GET")
        
        if callback then
                assert(type(callback) == "function", "callback must be function")
        end
        
        local authorize_url = options.authorize_url
 
        local post_data = {
         oauth_consumer_key = options.consumer_key,
         oauth_timestamp    = get_timestamp(),
         oauth_version      = '1.0',
         oauth_nonce        = get_nonce(),
         oauth_callback         = options.token_ready_url,
         oauth_signature_method = "HMAC-SHA1"
    }
    
    local result = oauth_sign(options.request_token_url,
                                                method,
                                                post_data,
                                                options.consumer_secret)
   
    if method == "GET" then
        return rawGetRequest(result,callback)
    else
                return rawPostRequest(options.request_token_url,result,callback)
    end
    
end
 
-- @return oauth_Access
local function getAccessByTokenAndSecret(token, token_secret, options)
    assert(options.consumer_key,"consumer_key option must be set")
    local consumer_key = options.consumer_key
    local consumer_secret = options.consumer_secret
    
    local function local_call(url, method, params,callback)
        local post_data = {
           oauth_consumer_key = consumer_key,
           oauth_timestamp    = get_timestamp(),
           oauth_version      = '1.0',
           oauth_nonce        = get_nonce(),
           oauth_token           = token,
           oauth_token_secret = token_secret,
           oauth_signature_method = "HMAC-SHA1"
        }
        for k,v in pairs(params) do
            post_data[k] = v
        end
        if (method == "POST") then
            post_data = oauth_sign(
                url,
                "POST",
                post_data,
                consumer_secret
            )
            return rawPostRequest(url, post_data,callback)
           
        elseif (method == "GET") then
            url = oauth_sign(
                url,
                "GET",
                post_data,
                consumer_secret
            )
            
            return rawGetRequest(url,callback)
            
        end
       
    end
    
    return {
        call = local_call
    }
    
end
 
 
local function parse_request_token_response(options, response)
    
    local token = response:match('oauth_token=([^&]+)')
    local secret = response:match('oauth_token_secret=([^&]+)')
    
        return {
                getAuthorizeUrl = function()    
                if token and secret then
                    return options.authorize_url .. "?" .. "oauth_token=" .. token .. "&" .. "oauth_callback=" .. options.token_ready_url;
            end
            return nil
        end,
        getToken = function()
                if token then
                return token
                        end             
            return nil
        end,
        getTokenSecret = function()
                if secret then
                return secret
                end   
            return nil
        end,
    } 
    
end
 
local function parse_access_token_response(options, response)
 
 local token = response:match('oauth_token=([^&]+)')
 local secret = response:match('oauth_token_secret=([^&]+)')
 local consumer_key = options.consumer_key
    
        return {
                getAccess = function()
                if token and secret then
                    return getAccessByTokenAndSecret(
                    token,
                        secret,
                    {
                       consumer_key = consumer_key
                        }
                )
            end
            return nil
        end,
        getToken = function()
                if token then
                return token
                        end             
            return nil
        end,
        getTokenSecret = function()
                if secret then
                return secret
                end   
            return nil
        end,
        getUserId = function()
            if response then
                return response:match(           'user_id=([^&]+)')
            end
            return nil  
        end,
        getScreenName = function()
            if response then
                return response:match(       'screen_name=([^&]+)')
            end
            return nil
        end
    } 
    
end
 
local function getAccessToken(token, verifier, token_secret, options, method, callback)
    assert(options.consumer_key,"consumer_key option must be set")
    assert(options.consumer_secret,"consumer_secret option must be set")
    assert(token,"oauth_token option must be set")
    assert(token_secret,"oauth_token_secret must be set")
    assert(options.access_token_url,"access_token_url option must be set")
    assert(method == "GET" or method == "POST","method must be either POST or GET")
    
    if callback then
                assert(type(callback) == "function", "callback must be function")
        end
        
    local consumer_key = options.consumer_key
    
    local post_data = {
       oauth_consumer_key = consumer_key,
       oauth_timestamp    = get_timestamp(),
       oauth_version      = '1.0',
       oauth_nonce        = get_nonce(),
       oauth_token        = options.oauth_token,
       oauth_token_secret = options.oauth_token_secret,
       oauth_verifier     = verifier,
       oauth_signature_method = "HMAC-SHA1", 
    }
    local post_data = oauth_sign(options.access_token_url,
                          method,
                          post_data,
                          options.consumer_secret)
    
    if method == "GET" then
        return rawGetRequest(result,callback)
    else
                return rawPostRequest(options.request_token_url,result,callback)
    end
        
end
 
local function getAccessTokenByPin(pin,method,options,callback)
    assert(options.consumer_key,"consumer_key option must be set")
    assert(options.consumer_secret,"consumer_secret option must be set")
    assert(options.oauth_token,"oauth_token option must be set")
    assert(options.oauth_token_secret,"oauth_token_secret must be set")
    assert(options.access_token_url,"access_token_url option must be set")
    assert(method == "GET" or method == "POST","method must be either POST or GET")
    assert(pin,"pin must be given")
    
    if callback then
                assert(type(callback) == "function", "callback must be function")
        end
        
    local consumer_key = options.consumer_key
   
        local post_data = {
       oauth_consumer_key = consumer_key,
       oauth_timestamp    = get_timestamp(),
       oauth_version      = '1.0',
       oauth_nonce        = get_nonce(),
       oauth_token        = options.oauth_token,
       oauth_token_secret = options.oauth_token_secret,
       oauth_verifier     = tostring(pin),
       oauth_signature_method = "HMAC-SHA1",
        }
    
    local post_data = oauth_sign(options.access_token_url,
                          "POST",
                          post_data,
                          options.consumer_secret)
                          
    rawPostRequest(options.access_token_url, post_data,callback)
  
end
 
consumer = {}
function newConsumer(options)
    assert(options.request_token_url,"request_token_url option must be set") 
    assert(options.authorize_url,"authorize_url option must be set") 
    assert(options.access_token_url,"access_token_url option must be set")
    assert(options.consumer_key,"consumer_key option must be set")
    assert(options.consumer_secret,"consumer_secret option must be set")
    assert(options.token_ready_url,"token_ready_url option must be set")
    
    local consumer_key = options.consumer_key
    local consumer_secret = options.consumer_secret
    local authorize_url = options.authorize_url
    local request_token_url = options.request_token_url
    local access_token_url = options.access_token_url
    local token_ready_url = options.token_ready_url
    
    function local_getRequestToken(method,callback)
        local auth_opts = {
            consumer_key = consumer_key,
            consumer_secret = consumer_secret,
            request_token_url = request_token_url,
            authorize_url = authorize_url,
            token_ready_url = token_ready_url,
        }
        return getRequestToken(auth_opts,method,callback)
    end
    
    function local_getAccessToken(token, verifier, token_secret,method,callback)
        local access_opts = {
            consumer_key = consumer_key,
            consumer_secret = consumer_secret,
            access_token_url = access_token_url
        }
        return getAccessToken(token, verifier, token_secret, access_opts,method,callback)
    end
    
    function local_parse_request_token_response(response)
        return parse_request_token_response(options,response)
    end
    
     
    function local_parse_access_token_response(response)
        return parse_access_token_response(options,response)
    end
    
    function local_getAccessTokenByPin(pin,method,options,callback)
        local access_opts = {
            consumer_key = options.consumer_key,
            consumer_secret = options.consumer_secret,
            access_token_url = options.access_token_url,
            oauth_token = options.oauth_token,
            oauth_token_secret = options.oauth_token_secret,
        }
        return getAccessTokenByPin(pin,method,access_opts,callback)
    end
    
    function local_getAccess(token, token_secret)
        return getAccessByTokenAndSecret(token, token_secret, { consumer_key = consumer_key,consumer_secret = consumer_secret })
    end
    
    return {
        getRequestToken = local_getRequestToken,
        getAccessToken = local_getAccessToken,
        getAccessTokenByPin = local_getAccessTokenByPin,
        getAccess = local_getAccess,
        parseRequestTokenResponse = local_parse_request_token_response, 
        parseAccessTokenResponse = local_parse_access_token_response,
    }
end