package cache

import (
	"backend/internal/domain"
	"backend/pkg/cache"
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/google/uuid"
	"github.com/redis/go-redis/v9"
)

type SessionRepository struct {
	redis *cache.Redis
}

func NewSessionRepository(redis *cache.Redis) domain.SessionRepo {
	return &SessionRepository{
		redis: redis,
	}
}

func (r *SessionRepository) Create(ctx context.Context, session *domain.UserSession) error {
	key := r.getSessionKey(session.ID)

	sessionData, err := json.Marshal(session)
	if err != nil {
		return fmt.Errorf("failed to marshal session: %w", err)
	}

	ttl := time.Until(session.ExpiresAt)
	if ttl <= 0 {
		return fmt.Errorf("session already expired")
	}

	if err := r.redis.Client().Set(ctx, key, sessionData, ttl).Err(); err != nil {
		return fmt.Errorf("failed to store session in Redis: %w", err)
	}

	userSessionsKey := r.getUserSessionsKey(session.UserID)
	if err := r.redis.Client().SAdd(ctx, userSessionsKey, session.ID.String()).Err(); err != nil {
		return fmt.Errorf("failed to add session to user sessions set: %w", err)
	}

	if err := r.redis.Client().Expire(ctx, userSessionsKey, ttl).Err(); err != nil {
		return fmt.Errorf("failed to set TTL for user sessions set: %w", err)
	}

	return nil
}

func (r *SessionRepository) GetByID(ctx context.Context, id uuid.UUID) (*domain.UserSession, error) {
	key := r.getSessionKey(id)

	result, err := r.redis.Client().Get(ctx, key).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, fmt.Errorf("session not found")
		}
		return nil, fmt.Errorf("failed to get session from Redis: %w", err)
	}

	var session domain.UserSession
	if err := json.Unmarshal([]byte(result), &session); err != nil {
		return nil, fmt.Errorf("failed to unmarshal session: %w", err)
	}

	if time.Now().After(session.ExpiresAt) {
		r.Delete(ctx, id)
		return nil, fmt.Errorf("session expired")
	}

	return &session, nil
}

func (r *SessionRepository) Delete(ctx context.Context, id uuid.UUID) error {
	key := r.getSessionKey(id)

	session, err := r.GetByID(ctx, id)
	if err != nil {
		return nil
	}

	if err := r.redis.Client().Del(ctx, key).Err(); err != nil {
		return fmt.Errorf("failed to delete session from Redis: %w", err)
	}

	userSessionsKey := r.getUserSessionsKey(session.UserID)
	if err := r.redis.Client().SRem(ctx, userSessionsKey, id.String()).Err(); err != nil {
		return fmt.Errorf("failed to remove session from user sessions set: %w", err)
	}

	return nil
}

func (r *SessionRepository) GetUserSessions(ctx context.Context, userID uuid.UUID) ([]domain.UserSession, error) {
	userSessionsKey := r.getUserSessionsKey(userID)

	sessionIDs, err := r.redis.Client().SMembers(ctx, userSessionsKey).Result()
	if err != nil {
		if err == redis.Nil {
			return []domain.UserSession{}, nil
		}
		return nil, fmt.Errorf("failed to get user sessions from Redis: %w", err)
	}

	var sessions []domain.UserSession
	for _, sessionIDStr := range sessionIDs {
		sessionID, err := uuid.Parse(sessionIDStr)
		if err != nil {
			r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
			continue
		}

		session, err := r.GetByID(ctx, sessionID)
		if err != nil {
			r.redis.Client().SRem(ctx, userSessionsKey, sessionIDStr)
			continue
		}

		sessions = append(sessions, *session)
	}

	return sessions, nil
}

func (r *SessionRepository) getSessionKey(sessionID uuid.UUID) string {
	return fmt.Sprintf("session:%s", sessionID.String())
}

func (r *SessionRepository) getUserSessionsKey(userID uuid.UUID) string {
	return fmt.Sprintf("user_sessions:%s", userID.String())
}