import { Request, Response } from 'express';

import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';

import { DyNTS_Controller } from '../../_services/route/controller.service';
import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
import { DyNTS_global_settings } from '../../_collections/global-settings.const';
import { DyNTS_Logs_Service } from './logs.service';

/**
 * Overseer-szintu log parameter tipus.
 * Az authPreProcess opcionalis — ha megadod, a /get endpoint vedett lesz.
 */
export interface DyNTS_LogsController_Config {
  /** Opcionalis auth preprocess. Ha nincs megadva → nyilt hozzaferes. */
  authPreProcess?: (req: Request, res: Response) => Promise<void>;
}

/**
 * NTS Logs Controller — beepitett /logs/get endpoint a szerver logok lekeresehez.
 *
 * Hasznalat:
 *   DyNTS_getLogsRoutingModule()  — auth nelkul
 *   DyNTS_getLogsRoutingModule({ authPreProcess: myAuth })  — auth-tal
 *
 * Ha a logs_endpoint.enabled === false, a controller 503-at dob.
 */
export class DyNTS_Logs_Controller extends DyNTS_Controller {

  private static config: DyNTS_LogsController_Config = {};

  static configure(config: DyNTS_LogsController_Config): void {
    DyNTS_Logs_Controller.config = config;
  }

  static getInstance(): DyNTS_Logs_Controller {
    return DyNTS_Logs_Controller.getSingletonInstance();
  }

  private readonly logsService: DyNTS_Logs_Service = DyNTS_Logs_Service.getInstance();

  setupEndpoints(): void {
    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
    if (DyNTS_Logs_Controller.config.authPreProcess) {
      preProcesses.push(DyNTS_Logs_Controller.config.authPreProcess);
    }

    this.endpoints = [
      // GET /get?tail=200 — utolso N sor a log bufferbol
      new DyNTS_Endpoint_Params({
        name: 'getLogs',
        type: DyFM_HttpCallType.get,
        endpoint: '/get',
        preProcesses: preProcesses,
        logRequest: false,
        tasks: [
          async (req: Request, res: Response): Promise<void> => {
            // Ellenorzes: be van-e kapcsolva a logs endpoint
            if (!DyNTS_global_settings.log_settings?.logs_endpoint?.enabled) {
              res.status(503).send({
                error: 'Logs endpoint is not enabled on this server.',
                hint: 'Set DyNTS_global_settings.log_settings.logs_endpoint.enabled = true',
              });
              return;
            }

            // Ellenorzes: install megtortent-e
            if (!this.logsService.isInstalled()) {
              res.status(503).send({
                error: 'Log buffer is not installed. Call DyNTS_Logs_Service.getInstance().install() at server startup.',
              });
              return;
            }

            const tail: number = Math.min(parseInt(req.query.tail as string) || 200, 2000);
            const lines: string[] = this.logsService.getLines(tail);

            res.send({
              totalBuffered: this.logsService.getLineCount(),
              returned: lines.length,
              lines: lines,
            });
          },
        ],
      }),

      // DELETE /clear — buffer uritese
      new DyNTS_Endpoint_Params({
        name: 'clearLogs',
        type: DyFM_HttpCallType.delete,
        endpoint: '/clear',
        preProcesses: preProcesses,
        logRequest: false,
        tasks: [
          async (req: Request, res: Response): Promise<void> => {
            if (!DyNTS_global_settings.log_settings?.logs_endpoint?.enabled) {
              res.status(503).send({ error: 'Logs endpoint is not enabled.' });
              return;
            }

            const count: number = this.logsService.getLineCount();
            this.logsService.clear();
            res.send({ result: 'Log buffer cleared', clearedLines: count });
          },
        ],
      }),
    ];
  }
}