const express = require('express');
const router = express.Router();
const fs = require("fs");
const jwt = require('jsonwebtoken');
const si = require("systeminformation");
const axios = require("axios");
const crypto = require("crypto");
const path = require('path');
const pool = require('../db'); // Dacă folosești baza de date mai târziu
const authenticateToken = require('../middleware/auth');

let localDeviceId = null;

// Obține deviceId local la pornirea aplicației
(async () => {
  try {
    const systemInfo = await si.system();
    const hardwareInfo = `${systemInfo.manufacturer}-${systemInfo.model}`;
    localDeviceId = crypto.createHash('sha256').update(hardwareInfo).digest('hex');
  } catch (error) {
    console.error('Eroare la obținerea deviceId:', error);
  }
})();

// === ROUTA: GET /device-id ===
router.get('/device-id', async (req, res) => {
  try {
    if (!localDeviceId) {
      throw new Error('DeviceId nu a putut fi generat');
    }
    res.json({ deviceId: localDeviceId });
  } catch (error) {
    console.error('Eroare la obținerea deviceId:', error);
    res.status(500).json({ error: 'Nu s-au putut obține informațiile hardware' });
  }
});

// === ROUTA: POST /sincronizeaza-licenta ===
router.post("/sincronizeaza-licenta", async (req, res) => {
  const tokenPath = path.join("./licenta.jwt");

  try {
    if (!fs.existsSync(tokenPath) || !fs.existsSync('./public.key')) {
      return res.status(400).json({
        message: "Fișierele de licență lipsesc.",
        valid: false
      });
    }

    const token = fs.readFileSync(tokenPath, "utf8");
    const publicKey = fs.readFileSync("./public.key", "utf8");

    const decodedToken = jwt.verify(token, publicKey, { algorithms: ["RS256"] });
    if (!decodedToken) {
      return res.status(400).json({ message: "Token invalid.", valid: false });
    }

    if (!decodedToken.end_date || isNaN(Date.parse(decodedToken.end_date))) {
      return res.status(400).json({ message: "Data de expirare lipsă sau invalidă în token.", valid: false });
    }

    if (new Date(decodedToken.end_date) < new Date()) {
      return res.status(403).json({ message: "Licența a expirat.", valid: false, expired: true });
    }

    // Obține informații firmă
    const firma = await axios.get("http://localhost:5000/api/firma/select_firma")
      .then(res => res.data[0])
      .catch(() => null);

    if (!firma) {
      return res.status(500).json({ message: "Nu s-au putut obține datele firmei.", valid: false });
    }

    if (decodedToken.cui !== firma.cui || decodedToken.denumire !== firma.denumire) {
      return res.status(403).json({
        message: "Licența nu corespunde cu datele firmei.",
        valid: false,
        details: {
          tokenCUI: decodedToken.cui,
          firmaCUI: firma.cui,
          tokenDenumire: decodedToken.denumire,
          firmaDenumire: firma.denumire
        }
      });
    }

    const response = await axios.post(
      "https://practicpos.ro/licentapos/valideaza-licenta",
      {
        token,
        deviceId: decodedToken.device_id,
        denumire: firma.denumire,
        cui: firma.cui
      }
    ).catch(err => {
      console.error("Eroare la validarea licenței:", err.message);
      return { data: { valid: false, error: err.message } };
    });

    if (!response.data.valid) {
      return res.status(403).json({
        message: response.data.message || "Licența nu este validă pe serverul principal.",
        valid: false,
        details: response.data
      });
    }

    const zileRamase = Math.ceil(
      (new Date(decodedToken.end_date) - new Date()) / (1000 * 60 * 60 * 24)
    );

    return res.json({
      message: "Licența este validă.",
      valid: true,
      zileRamase
    });

  } catch (err) {
    console.error("Eroare la sincronizare:", err.message);
    return res.status(500).json({
      message: "Eroare la validare licență.",
      valid: false,
      details: err.message
    });
  }
});

// === ROUTA: GET /zile-ramase ===
router.get('/zile-ramase', async (req, res) => {
  try {
    if (!fs.existsSync('./licenta.jwt') || !fs.existsSync('./public.key')) {
      return res.status(400).json({ message: 'Fișierul licenței lipsește.' });
    }

    const token = fs.readFileSync('./licenta.jwt', 'utf8');
    const publicKey = fs.readFileSync('./public.key', 'utf8');
    const decoded = jwt.verify(token, publicKey, { algorithms: ['RS256'] });

    if (!decoded.end_date || isNaN(Date.parse(decoded.end_date))) {
      return res.status(400).json({ message: 'Data de expirare din token este invalidă.' });
    }

    if (decoded.device_id !== localDeviceId) {
      return res.status(403).json({
        message: 'Tokenul este asociat altui dispozitiv.',
        valid: false
      });
    }

    const zileRamase = Math.ceil(
      (new Date(decoded.end_date) - new Date()) / (1000 * 60 * 60 * 24)
    );

    if (zileRamase < 0) {
      return res.status(403).json({
        message: 'Licența a expirat.',
        valid: false,
        expired: true
      });
    }

    res.json({
      zileRamase,
      valid: true
    });

  } catch (err) {
    console.error('Eroare la verificarea licenței:', err.message);
    res.status(500).json({
      message: 'Eroare la verificarea licenței.',
      valid: false
    });
  }
});

module.exports = router;
