package server

import (
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"strings"
	"time"

	"github.com/pborman/uuid"
	"gopkg.in/redis.v2"
	"xiaoniaokuaiyan.com/xiaoniao/config"
	"xiaoniaokuaiyan.com/xiaoniao/util"
)

type AuthToken struct {
	AccessToken string    `json:"access_token"`
	TokenType   string    `json:"token_type,omitempty"`
	Expiry      util.Time `json:"expiry,omitempty"`
	ClientId    string    `json:"clientid"`
	Iss         string    `json:"iss"`
}

// expired reports whether the token is expired.
// t must be non-nil.
func (t *AuthToken) expired() bool {
	if t.Expiry.IsZero() {
		return false
	}
	return t.Expiry.Add(-10 * time.Second).Before(time.Now())
}

// Valid reports whether t is non-nil, has an accessToken, and is not expired.
func (t *AuthToken) IsValid() bool {
	return t != nil && t.AccessToken != "" && !t.expired()
}

/*func (t *AuthToken) MarshalJSON() ([]byte, error) {
	return json.Marshal(struct {
		accessToken string `json:"access_token"`
		TokenType   string `json:"token_type"`
		Expiry      int64  `json:"expiry"`
		Iss         string `json:"iss"`
	}{
		accessToken: t.accessToken,
		TokenType:   t.TokenType,
		Expiry:      t.Expiry.Unix(),
		Iss:         t.Iss,
	})
}
func (t *AuthToken) UnmarshalJSON(buf []byte) err{

}*/

type SessionToken struct {
	Token string      `json:"token"`
	Data  interface{} `json:"data"`
}

/*func (st *SessionToken) IsValid() bool {
	if isExp := st.Expiry.Add(-10 * time.Second).Before(time.Now()); isExp {
		return false
	}
	return st.Token != ""
}*/

//刷新登录会话token过期时间
func TouchSessionToken(tokenStr string) (*SessionToken, error) {
	var client *redis.Client = util.GetRedis()
	client.Select(REDIS_API_AUTH_DB)
	/*strCmd := client.HGet(REDIS_API_SESSION_KEY, tokenStr)
	if err := strCmd.Err(); err != nil {
		return nil, err
	}
	sessionToken := &SessionToken{}
	err := json.Unmarshal([]byte(strCmd.Val()), sessionToken)
	if err != nil {
		return nil, err
	}
	sessionToken.Expiry = util.Time{time.Now().Add(time.Hour * 24)}
	sb, _ := json.Marshal(sessionToken)
	bcmd := client.HSet(REDIS_API_SESSION_KEY, tokenStr, string(sb))
	if err := bcmd.Err(); err != nil {
		return nil, err
	}*/
	var exp int64
	exp, _ = config.IniConf.Section("server").Key("redis_api_session_expire").Int64()
	if exp < 30 {
		exp = 60
	}
	bcmd := client.Expire(tokenStr, time.Minute*time.Duration(exp))
	if err := bcmd.Err(); err != nil {
		return nil, err
	}
	return nil, nil
}
func GenerateSessionToken(userid string) *SessionToken {
	token := uuid.NewRandom()
	tokenStr := strings.TrimRight(base64.URLEncoding.EncodeToString([]byte(token)), "=")
	return &SessionToken{
		Token: tokenStr,
		Data:  userid,
	}
}

func GenerateSessionId(userid string, source string) string {
	sessStr := fmt.Sprintf("%v-%v", userid, source)
	dst := md5.Sum([]byte(sessStr))
	return hex.EncodeToString(dst[0:])
}

func GetLoginSession(token string) (*SessionToken, error) {
	var client *redis.Client = util.GetRedis()
	client.Select(REDIS_API_AUTH_DB)
	strCmd := client.Get(token)
	if err := strCmd.Err(); err != nil {
		return nil, err
	}
	sessionToken := &SessionToken{}
	err := json.Unmarshal([]byte(strCmd.Val()), sessionToken)
	if err != nil {
		return nil, err
	}
	return sessionToken, nil

}