// 創(chuàng)建載體方式對(duì)象（cookie-based）
store := cookie.NewStore([]byte("secret"))
r.Use(sessions.Sessions("sessionId", store))
r.GET("/hello", func(c *gin.Context) {
    // session中間使用
    session := sessions.Default(c)
    if session.Get("hello") != "world" {
        session.Set("hello", "world")
        session.Save()
    }
    ....
})

router := gin.Default()
// @Todo 創(chuàng)建store對(duì)象
store, err := sessions.NewRedisStore(10, "tcp", "localhost:6379", "", []byte("secret"))
    if err != nil {log.Fatal(" sessions.NewRedisStore err is :%v", err)}
router.GET("/admin", func(c *gin.Context) {
        session := sessions.Default(c)
        var count int
        v := session.Get("count")
        if v == nil {
            count = 0
        } else {
            count = v.(int)
            count++
        }
        session.Set("count", count)
        session.Save()
        c.JSON(200, gin.H{"count": count})
    })

func NewRediStore(size int, network, address, password string, keyPairs ...[]byte) (*RediStore, error) {
    return NewRediStoreWithPool(&redis.Pool{
        MaxIdle:     size,
        IdleTimeout: 240 * time.Second,
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
        Dial: func() (redis.Conn, error) {
            return dial(network, address, password)
        },
    }, keyPairs...)
}
// NewRediStoreWithPool instantiates a RediStore with a *redis.Pool passed in.
func NewRediStoreWithPool(pool *redis.Pool, keyPairs ...[]byte) (*RediStore, error) {
    rs := &RediStore{
        // http://godoc.org/github.com/gomodule/redigo/redis#Pool
        Pool:   pool,
        Codecs: securecookie.CodecsFromPairs(keyPairs...),
        Options: &sessions.Options{
            Path:   "/", // 客戶(hù)端的 Path
            MaxAge: sessionExpire, // 客戶(hù)端的Expires/MaxAge
        },
        DefaultMaxAge: 60 * 20, // 過(guò)期時(shí)間是20分鐘
        maxLength:     4096, // 最大長(zhǎng)度
        keyPrefix:     "session_", // key 前綴
        serializer:    GobSerializer{}, // 內(nèi)部序列化采用了Gob庫(kù)
    }
    // @Todo 嘗試創(chuàng)建連接
    _, err := rs.ping()
    return rs, err
}

// Use adds middleware to the group, see example code in GitHub.
func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
    group.Handlers = append(group.Handlers, middleware...)
    return group.returnObj()
}

const (
    DefaultKey  = "github.com/gin-gonic/contrib/sessions"
    errorFormat = "[sessions] ERROR! %s\n"
)


func Sessions(name string, store Store) gin.HandlerFunc {
    return func(c *gin.Context) {
        s := &session{name, c.Request, store, nil, false, c.Writer}
        c.Set(DefaultKey, s)
        defer context.Clear(c.Request)
        c.Next()
    }
}

type session struct {
    name    string
    request *http.Request
    store   Store
    session *sessions.Session
    written bool
    writer  http.ResponseWriter
}

// shortcut to get session
func Default(c *gin.Context) Session {
    return c.MustGet(DefaultKey).(Session)
}

// @Todo SessionKey 中獲取用戶(hù)信息
session := sessions.Default(c)
sessionInfo := session.Get(public.AdminSessionInfoKey)

type session struct {
    name    string
    request *http.Request
    store   Store
    session *sessions.Session // 實(shí)際內(nèi)部數(shù)據(jù)交換
    written bool
    writer  http.ResponseWriter
}
func (s *session) Get(key interface{}) interface{} {
    // 通過(guò)s.Session() 獲取具體的session；具體的值保存在 Values 這個(gè)map 中
    return s.Session().Values[key]
}
func (s *session) Session() *sessions.Session {
    if s.session == nil {
        var err error
        s.session, err = s.store.Get(s.request, s.name)
        if err != nil {
            log.Printf(errorFormat, err)
        }
    }
    return s.session
}

// Session stores the values and optional configuration for a session.
type Session struct {
    // The ID of the session, generated by stores. It should not be used for
    // user data.
    ID string
    // Values contains the user-data for the session.
    Values  map[interface{}]interface{}
    Options *Options
    IsNew   bool
    store   Store
    name    string
}

// s.request 請(qǐng)求
// s.name session名
s.session, err = s.store.Get(s.request, s.name)

// @Todo 在路由層注入session的時(shí)候 Seesions 方法其實(shí)就初始化了這個(gè)session的name 和其他值，只是保存的session是 nil
sessions.Sessions("sessionId", store)

// Get returns a session for the given name after adding it to the registry.
//
// See gorilla/sessions FilesystemStore.Get().
func (s *RediStore) Get(r *http.Request, name string) (*sessions.Session, error) {
    return sessions.GetRegistry(r).Get(s, name)
}

// GetRegistry 本質(zhì)就是返回一個(gè) Registry 的一個(gè)結(jié)構(gòu)體
func GetRegistry(r *http.Request) *Registry {
    registry := context.Get(r, registryKey)
    if registry != nil {
        return registry.(*Registry)
    }
    newRegistry := &Registry{
        request:  r,
        sessions: make(map[string]sessionInfo),
    }
    context.Set(r, registryKey, newRegistry)
    return newRegistry
}
// Registry stores sessions used during a request.
type Registry struct {
    request  *http.Request
    sessions map[string]sessionInfo
}
// Get registers and returns a session for the given name and session store.
//
// It returns a new session if there are no sessions registered for the name.
func (s *Registry) Get(store Store, name string) (session *Session, err error) {
    if !isCookieNameValid(name) {
        return nil, fmt.Errorf("sessions: invalid character in cookie name: %s", name)
    }
    if info, ok := s.sessions[name]; ok {
        session, err = info.s, info.e
    } else {
        session, err = store.New(s.request, name)
        session.name = name
        s.sessions[name] = sessionInfo{s: session, e: err}
    }
    session.store = store
    return
}

// New returns a session for the given name without adding it to the registry.
//
// See gorilla/sessions FilesystemStore.New().
func (s *RediStore) New(r *http.Request, name string) (*sessions.Session, error) {
    var (
        err error
        ok  bool
    )
    // @Todo 初始化一個(gè)業(yè)務(wù)的session 
    session := sessions.NewSession(s, name)
    // make a copy
    options := *s.Options
    session.Options = &options
    session.IsNew = true
    // @Todo 根據(jù)session_name讀取cookie中的sessionID
    if c, errCookie := r.Cookie(name); errCookie == nil {
        // @Todo 編解碼器對(duì)cookie值進(jìn)行解碼
        err = securecookie.DecodeMulti(name, c.Value, &session.ID, s.Codecs...)
        if err == nil {
            // @Todo redis中根據(jù)sessionID 獲取具體的 sessionInfo
            ok, err = s.load(session)
            session.IsNew = !(err == nil && ok) // not new if no error and data available
        }
    }
    return session, err
}

// @Todo 寫(xiě)值入口 （其實(shí)就是session map 中賦值一下）
func (s *session) Set(key interface{}, val interface{}) {
    s.Session().Values[key] = val
    s.written = true
}
func (s *session) Save() error {
    if s.Written() {
        e := s.Session().Save(s.request, s.writer)
        if e == nil {
            s.written = false
        }
        return e
    }
    return nil
}
// Save is a convenience method to save this session. It is the same as calling
// store.Save(request, response, session). You should call Save before writing to
// the response or returning from the handler.
func (s *Session) Save(r *http.Request, w http.ResponseWriter) error {
    return s.store.Save(r, w, s)
}
// Save adds a single session to the response.
func (s *RediStore) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
    // @Todo 刪除session并把cookie中也強(qiáng)制過(guò)期
    if session.Options.MaxAge <= 0 {
        if err := s.delete(session); err != nil {
            return err
        }
        http.SetCookie(w, sessions.NewCookie(session.Name(), "", session.Options))
    } else {
        // @Todo 如果沒(méi)SessionID 就隨機(jī)生成一個(gè)sessionID （并發(fā)來(lái)的時(shí)候是否會(huì)生成相同SessionID）
        if session.ID == "" {
            session.ID = strings.TrimRight(base32.StdEncoding.EncodeToString(securecookie.GenerateRandomKey(32)), "=")
        }
        // @Todo 將session的值寫(xiě)入redis
        if err := s.save(session); err != nil {
            return err
        }
        // @Todo cookie編碼一下
        encoded, err := securecookie.EncodeMulti(session.Name(), session.ID, s.Codecs...)
        if err != nil {
            return err
        }
        // @Todo 根據(jù)session的屬性，寫(xiě)入 cookie （SessionID, path, maxAge等）
        http.SetCookie(w, sessions.NewCookie(session.Name(), encoded, session.Options))
    }
    return nil
}