package lishwist

import (
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"lishwist/core/internal/db"
	"time"
)

type Session struct {
	Id        string
	Token     string
	User      *User
	ExpiresAt time.Time
	CreatedAt time.Time
}

type SessionManager struct {
	sessionDuration    time.Duration
	sessionTokenLength uint
}

func NewSessionManager(sessionDuration time.Duration, sessionTokenLength uint) SessionManager {
	return SessionManager{
		sessionDuration,
		sessionTokenLength,
	}
}

func generateSecureToken(size uint) (string, error) {
	bytes := make([]byte, size)
	if _, err := rand.Read(bytes); err != nil {
		return "", err
	}
	return base64.URLEncoding.EncodeToString(bytes), nil
}

func (sm *SessionManager) createSession(user *User) (*Session, error) {
	stmt := "INSERT INTO session (user_id) VALUES (?);"
	result, err := db.Connection.Exec(stmt, user.Id)
	if err != nil {
		return nil, fmt.Errorf("Failed to execute query: %w", err)
	}
	id, err := result.LastInsertId()
	if err != nil {
		return nil, fmt.Errorf("Failed to get last insert id: %w", err)
	}

	token, err := generateSecureToken(sm.sessionTokenLength)
	if err != nil {
		return nil, fmt.Errorf("Failed to generate secure token: %w", err)
	}

	session := Session{
		Id:        fmt.Sprintf("%d", id),
		Token:     token,
		User:      user,
		ExpiresAt: time.Now().Add(sm.sessionDuration),
		CreatedAt: time.Now(),
	}

	return &session, nil
}