const { Pool } = require('pg');
const { hash, generateShortId } = require('./cryptoUtils');

const pool = new Pool({
    user: process.env.DB_USER,
    host: process.env.DB_HOST,
    database: process.env.DB_NAME,
    password: process.env.DB_PASSWORD,
    port: process.env.DB_PORT,
});

async function checkDB() {
    try {
        await pool.query('SELECT NOW()');
        return true;
    } catch (error) {
        console.error('Database connection failed:', error);
        return false;
    }
}

async function initDB() {
    try {
        await pool.query(`
            CREATE TABLE IF NOT EXISTS sensors (
                id VARCHAR(10) PRIMARY KEY,
                name VARCHAR(100) NOT NULL,
                code_hash TEXT NOT NULL UNIQUE,
                is_active BOOLEAN DEFAULT TRUE,
                last_seen TIMESTAMP DEFAULT NOW(),
                created_at TIMESTAMP DEFAULT NOW()
            );
            CREATE INDEX IF NOT EXISTS idx_sensors_code_hash ON sensors(code_hash);
        `);
        console.log('[DB] Database schema initialized (sensors table ensured)');
    } catch (error) {
        console.error('[DB] Schema initialization failed:', error);
    }
}

/**
 * Restituisce i dati del sensore in base al token ricevuto.
 * Il token viene hashato prima della comparazione con il database.
 * @param {string} token - il codice segreto del sensore (raw)
 */
async function getSensor(token) {
    const hashed = hash(token);
    const result = await pool.query('SELECT id, is_active, name, last_seen, created_at FROM sensors WHERE code_hash = $1', [hashed]);
    return result.rows[0];
}

async function createSensor(name, code) {
    const hashedCode = hash(code);

    // Verifica se l'hash esiste già
    const result = await pool.query('SELECT id FROM sensors WHERE code_hash = $1', [hashedCode]);
    if (result.rows.length > 0) {
        throw new Error('Sensor with this code already exists');
    }

    // Genera un ID casuale di 8 caratteri (ottimizzato per spazio, non solo alfanumerico)
    const sensorId = generateShortId(8);

    await pool.query('INSERT INTO sensors (id, name, code_hash, is_active, last_seen, created_at) VALUES ($1, $2, $3, $4, $5, $6)',
        [sensorId, name, hashedCode, true, new Date(), new Date()]);
}

/**
 * Aggiorna l'ultima attività del sensore.
 * @param {*} id - l'id del sensore
 * @returns {Promise<void>}
 */
async function updateLastSeen(id) {
    await pool.query('UPDATE sensors SET last_seen = NOW() WHERE id = $1', [id]);
}

/**
 * Modifica la disponibilità del sensore.
 * @param {*} id - l'id del sensore
 * @param {*} is_active - la disponibilità del sensore
 * @returns {Promise<void>}
 */
async function setSensorActivity(id, is_active) {
    await pool.query('UPDATE sensors SET is_active = $1 WHERE id = $2', [is_active, id]);
}

async function sensorsExists(id) {
    const result = await pool.query('SELECT id FROM sensors WHERE id = $1', [id]);
    return result.rows.length > 0;
}

async function getSensors() {
    const resutls = await pool.query('SELECT id, is_active, name, last_seen, created_at FROM sensors');
    return resutls.rows;
}

module.exports = {
    checkDB,
    initDB,
    getSensor,
    updateLastSeen,
    setSensorActivity,
    getSensors,
    sensorsExists,
    createSensor
}