import dotenv from 'dotenv';
import { createClient } from 'redis';
import User from '../models/community/user.js';

dotenv.config();

const EXPIRATION_TIME = 30 * 60 * 1000;

const redisClient = createClient({
    url: `redis://${process.env.REDIS_HOST}:${process.env.REDIS_PORT}`,
    password: process.env.REDIS_PASSWORD,
    legacyMode: false, 
});

redisClient.connect().catch(console.error);

const setUserSession = async (userId, sessionData) => {
    try {
        await redisClient.sendCommand(['JSON.SET', `user:${userId}`, '.', JSON.stringify(sessionData)]);
        console.log(userId, sessionData);
        const sessionDataStr = await redisClient.sendCommand(['JSON.GET', `user:${userId}`]);
        console.log(sessionDataStr);
    } catch (error) {
        console.error('Fehler beim Setzen der Benutzersitzung:', error);
    }
}; 

const deleteUserSession = async (userId) => {
    try {
        const result = await redisClient.del(`user:${userId}`);
        if (result === 1) {
            console.log(`Benutzersitzung für Benutzer ${userId} erfolgreich gelöscht.`);
        } else {
            console.warn(`Benutzersitzung für Benutzer ${userId} war nicht vorhanden.`);
        }
    } catch (error) {
        console.error('Fehler beim Löschen der Benutzersitzung:', error);
    }
};

const convertToOriginalType = (value) => {
    if (value === 'true') return true;
    if (value === 'false') return false;
    if (!isNaN(value) && value.trim() !== '') return Number(value); 
    return value; 
};

const getUserSession = async (userId) => {
    try {
        const sessionData = await redisClient.sendCommand(['JSON.GET', `user:${userId}`]);
        return JSON.parse(sessionData);
    } catch (error) {
        console.error('Fehler beim Abrufen der Benutzersitzung:', error);
        return null;
    }
};

const updateUserTimestamp = async (userId) => {
    try {
        const userKey = `user:${userId}`;
        const userExists = await redisClient.exists(userKey);
        if (userExists) {
            const sessionDataString = await redisClient.sendCommand(['JSON.GET', `user:${userId}`]);
            const sessionData = JSON.parse(sessionDataString);
            sessionData.timestamp = Date.now();
            await redisClient.sendCommand(['JSON.SET', `user:${userId}`, '.', JSON.stringify(sessionData)]);
        }
    } catch (error) {
        console.error('Fehler beim Aktualisieren des Zeitstempels:', error);
    }
};

const cleanupExpiredSessions = async () => {
    try {
        const keys = await redisClient.keys('user:*');
        const now = Date.now();

        for (const key of keys) {
            try {
                const sessionStr = await redisClient.sendCommand(['JSON.GET', key]);
                if (sessionStr) {
                    const session = JSON.parse(sessionStr);
                    if (session.timestamp && now - parseInt(session.timestamp) > EXPIRATION_TIME) {
                        const userId = key.split(':')[1];
                        await redisClient.del(key);
                        await User.update({ authCode: '' }, { where: { hashedId: userId } });
                        console.log(`Abgelaufene Sitzung für Benutzer ${userId} mit RedisJSON gelöscht.`);
                    }
                }
            } catch (error) {
                if (error.message.includes('WRONGTYPE')) {
                    console.warn(`Schlüssel ${key} ist kein JSON-Objekt, wird übersprungen.`);
                } else {
                    console.error(`Fehler beim Bereinigen für Schlüssel ${key}:`, error);
                }
            }
        }
    } catch (error) {
        console.error('Fehler beim Bereinigen abgelaufener Sitzungen mit RedisJSON:', error);
    }
};

export {
    setUserSession,
    deleteUserSession,
    getUserSession,
    updateUserTimestamp,
    cleanupExpiredSessions,
    redisClient
};