import assert from 'assert';
import express, { Router, type NextFunction, type Request, type Response } from 'express';
import { errorHandler } from './aplication/middleware.js';
import { env } from './config/env.config.js';

import cors from 'cors';

import type { ServerContext } from 'domain/ServerContext.js';
import { httpclient } from 'config/httpclient.config.js';
import { pgClient } from 'config/pgclient.config.js';
import { NfcController } from 'aplication/Nfc.controller.js';
import { NfcUsecases } from 'aplication/Nfc.usecases.js';
import { NfcRepository } from 'infrastructure/Nfc.repository.js';
import { LogRepository, type LogCreateDTO } from 'infrastructure/Log.repository.js';

const PORT = env.PORT
const HOSTNAME = env.HOST

assert(HOSTNAME != undefined)


// Instancias de las dependencias

const serverContext: ServerContext = {
    HttpClient: httpclient,
    PostgresClient: pgClient
}

const nfcRepository = new NfcRepository(serverContext)
const logRepository = new LogRepository(serverContext)

const nfcUsecases = new NfcUsecases({
    serverContext,
    nfcRepository
})

const ncfControllers = new NfcController({
    serverContext,
    nfcUsecases
})

// middleware

const requestLogger = (req: Request, res: Response, next: NextFunction) => {
    const timestamp = new Date().toISOString();
    const method = req.method;
    const url = req.url;
    const body = req.body;

    // 'origin' comes from the request headers
    const origin = req.get('origin') || 'No Origin (likely direct request/Server-side)';
    const log: LogCreateDTO = {
        data: req.body,
        endpoint: method + " " + req.url,
        origin: origin
    }
    logRepository.createLog(log).then().catch(e => console.error("Error logueando ", log, e))
    console.log(`[${timestamp}] ${method} ${url} - Origin: ${origin} - Body: ${JSON.stringify(body)}`);

    // Crucial: Call next() so the request doesn't hang!
    next();
};

const responseLogger = (req: Request, res: Response, next: NextFunction) => {
    const timestamp = new Date().toISOString();
    const start = Date.now();
    const oldSend = res.send;


    res.send = function (data: any): Response {
        // @ts-ignore: Si, es poco ortodoxo
        res.sendBody = data; // Store the result data
        return oldSend.apply(res, [data]);
    };

    // Listen for the 'finish' event to log after the response is sent
    res.on('finish', () => {
        const duration = Date.now() - start;
        const log: LogCreateDTO = {
            // @ts-ignore: Por lo de antes
            data: res.sendBody,
            endpoint: req.method + " " + req.originalUrl,
            origin: "SERVER"
        }
        logRepository.createLog(log)
        console.log(`[${timestamp} ${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`);
    });

    next();
}

// Rutas

const router = Router();

router.get("/health", (req: Request, res: Response) => {
    res.json({ ok: true })
})

router.post("/nfc/generate", ncfControllers.generateActivationTag())
router.head("/", (req, res) => res.status(200).send())

// Inicio de express

const app = express();

app.use(express.json());

app.use(cors({
    origin: '*',
    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
    allowedHeaders: ['Content-Type', 'Authorization']
}))

app.use(requestLogger)
app.use(responseLogger)

// Routes
app.use('/', router);

app.use(errorHandler);

app.listen(PORT, HOSTNAME, (n) => {
    console.log(`[o] Servidor escuchando en ${HOSTNAME}:${PORT}`)
})