// fetch-and-generate-openapi.js
import fs from 'fs';
import https from 'https'; // Use https instead of http
import { exec } from 'child_process';
import chokidar from 'chokidar';
import path from 'path';
import util from 'util';

const OPENAPI_URL = 'https://127.0.0.1:8000/openapi.json';
const SCHEMA_PATH = path.resolve('./src/openapi.json');
const OUTPUT_DIRECTORY = path.resolve('./openapi');
const SSL_KEY_PATH = path.resolve('../backend/ssl/key.pem');  // Path to SSL key
const SSL_CERT_PATH = path.resolve('../backend/ssl/cert.pem'); // Path to SSL certificate

console.log(`Using SCHEMA_PATH: ${SCHEMA_PATH}`);
console.log(`Using OUTPUT_DIRECTORY: ${OUTPUT_DIRECTORY}`);

const execPromisified = util.promisify(exec);

let isGenerating = false;
const debounceDelay = 500;  // 500ms debounce

function debounce(func, delay) {
    let timer;
    return (...args) => {
        clearTimeout(timer);
        timer = setTimeout(() => {
            func.apply(this, args);
        }, delay);
    };
}

async function fetchAndGenerate() {
    if (isGenerating) {
        console.log("⚠️ Generation is already running.");
        return;
    }
    isGenerating = true;

    console.log("🚀 Fetching OpenAPI schema...");

    try {
        const options = {
            rejectUnauthorized: false,
            key: fs.readFileSync(SSL_KEY_PATH),
            cert: fs.readFileSync(SSL_CERT_PATH),
        };

        const res = await new Promise((resolve, reject) => {
            https.get(OPENAPI_URL, options, resolve).on('error', reject);
        });

        let data = '';
        res.on('data', (chunk) => {
            data += chunk;
        });

        res.on('end', async () => {
            try {
                fs.writeFileSync(SCHEMA_PATH, data, 'utf8');
                console.log(`✅ OpenAPI schema saved to ${SCHEMA_PATH}`);
            } catch (writeError) {
                console.error(`❌ Error saving OpenAPI schema: ${writeError}`);
                isGenerating = false;
                return;
            }

            console.log("🧼 Cleaning output directory...");
            try {
                await fs.promises.rm(OUTPUT_DIRECTORY, { recursive: true, force: true });
                console.log(`✅ Output directory cleaned at ${OUTPUT_DIRECTORY}`);

                // Verify directory removal
                if (fs.existsSync(OUTPUT_DIRECTORY)) {
                    console.error(`❌ Output directory still exists: ${OUTPUT_DIRECTORY}`);
                } else {
                    console.log(`✅ Confirmed removal of ${OUTPUT_DIRECTORY}`);
                }

                const command = `npx openapi -i ${SCHEMA_PATH} -o ${OUTPUT_DIRECTORY}`;
                console.log(`Executing debug command: ${command}`);

                const { stdout, stderr } = await execPromisified(command);
                console.log("🔍 Inside exec callback");
                if (stderr) {
                    console.error(`⚠️ stderr while generating services: ${stderr}`);
                } else {
                    console.log(`✅ Command executed successfully, output:\n${stdout}`);
                }
            } catch (error) {
                console.error(`❌ Error cleaning or executing command: ${error}`);
            }

            isGenerating = false;
        });
    } catch (error) {
        console.error('❌ Error fetching OpenAPI schema: ' + error.message);
        isGenerating = false;
    }
}

const backendDirectory = '/Users/gotthardg/PycharmProjects/heidi-v2/backend/app';
console.log(`👀 Watching for changes in ${backendDirectory}`);
const watcher = chokidar.watch(backendDirectory, { persistent: true, ignored: [SCHEMA_PATH, OUTPUT_DIRECTORY] });

watcher
    .on('add', debounce(fetchAndGenerate, debounceDelay))
    .on('change', debounce(fetchAndGenerate, debounceDelay))  // Corrected typo here
    .on('unlink', debounce(fetchAndGenerate, debounceDelay));

console.log(`👀 Watching for changes in ${backendDirectory}`);