// Package files implements sessions saved into filesystem persistently encoded using gob
package files

import (
	"bytes"
	"container/list"
	"encoding/gob"
	"fmt"
	"os"
	"sync"
	"time"

	"github.com/djherbis/atime"
)

const (
	sessDir string = "go-session"
	sessExt string = "gsd"
)

func init() {

}

// ProviderFiles implement filesystem session provider
type ProviderFiles struct {
	lock     sync.Mutex
	list     *list.List //or gc
	sessPath string
}

func (pder *ProviderFiles) ckdirpath(sid string) string {
	return fmt.Sprintf("%s/%s/%s.%s", pder.sessPath, sessDir, sid, sessExt)
}

func (pder *ProviderFiles) updateAtime(sid string) (err error) {
	pth := pder.ckdirpath(sid)
	return os.Chtimes(pth, time.Now(), time.Time{})
}

func (pder *ProviderFiles) getAtime(sid string) (atm time.Time, err error) {
	pth := pder.ckdirpath(sid)
	return atime.Stat(pth)
}

// SetParams for files session provider set base path in filesystem for save sessions
func (pder *ProviderFiles) SetParams(p any) (err error) {
	if p != nil {
		if s, ok := p.(string); ok {
			pder.sessPath = s
			return
		}
		return fmt.Errorf("parameter for files session provider is not string")
	}
	return fmt.Errorf("parameter for files session provider must not be nil")
}

// Init create empty session file if not exists and retturn *Session
func (pder *ProviderFiles) Init(sid string) (err error) {
	pder.lock.Lock()
	defer pder.lock.Unlock()
	var fd *os.File
	ckf := pder.ckdirpath(sid)
	if fd, err = os.Create(ckf); err != nil {
		return fmt.Errorf("create session file: %s failed with err: %w", ckf, err)
	}
	pder.list.PushBack(sid)
	return fd.Close()
}

// SessionFile save session data into files using gob encode/dacode
type SessionFile struct {
	sfpth string
}

// load data from session file
func (sf *SessionFile) load() (data map[any]any, err error) {
	var sb []byte
	if sb, err = os.ReadFile(sf.sfpth); err != nil {
		return nil, fmt.Errorf("Session file: %s read error: %v", sf.sfpth, err)
	}
	var gobdata bytes.Buffer
	if _, err = gobdata.Write(sb); err != nil {
		return nil, fmt.Errorf("Load session file: %s into buffer err: %v", sf.sfpth, err)
	}
	dec := gob.NewDecoder(&gobdata)
	if err = dec.Decode(&data); err != nil {
		return nil, fmt.Errorf("Decode gob data from file: %s error: %v", sf.sfpth, err)
	}
	return
}

// save data into session file
func (sf *SessionFile) save(data map[any]any) (err error) {
	var gobdata bytes.Buffer
	enc := gob.NewEncoder(&gobdata)
	if err = enc.Encode(data); err != nil {
		return fmt.Errorf("Gob encode file: %s error: %v", sf.sfpth, err)
	}
	if err = os.WriteFile(sf.sfpth, gobdata.Bytes(), 0o600); err != nil {
		return fmt.Errorf("Write gob data into file: %s error: %v", sf.sfpth, err)
	}
	return nil
}

// Get value from session key k
func (sf *SessionFile) Get(k any) (v any, err error) {
	var data map[any]any
	if data, err = sf.load(); err != nil {
		return nil, err
	}
	return data[k], nil
}

// Set value of key k to v
func (sf *SessionFile) Set(k, v any) (err error) {
	//var data map[any]any
	return
}