import { Request, Response } from 'express';

import { DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
import {
  DyFM_usageModule_settings, DyFM_UsageSession
} from '@futdevpro/fsm-dynamo/usage';

import {
  DyNTS_Endpoint_Params
} from '../../_models/control-models/endpoint-params.control-model';
import { DyNTS_AuthService } from '../../_services/core/auth.service';
import { DyNTS_GlobalService } from '../../_services/core/global.service';
import { DyNTS_Controller } from '../../_services/route/controller.service';
import { DyNTS_Usage_DataService } from './usage.data-service';

export class DyNTS_Usage_Controller extends DyNTS_Controller {

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

  // SERVICES
  private authService: DyNTS_AuthService;

  setupEndpoints(): void {
    this.authService = DyNTS_GlobalService.getAuthService();

    this.endpoints = [
      new DyNTS_Endpoint_Params({
        name: 'newSession',
        type: DyFM_HttpCallType.get,
        endpoint: DyFM_usageModule_settings.endPoints.newSession,
        tasks: [
          async (req: Request, res: Response, issuer: string): Promise<void> => {
            let username: string;
            
            try {
              username = this.authService.getUsernameFromRequest(req);
            } catch {
              username = 'unknown';
            }
            const usageService = new DyNTS_Usage_DataService({
              usageSession: new DyFM_UsageSession({
                sessionStart: new Date(),
                issuer: username,
              }),
              issuer,
            });

            await usageService.getLocationDataFromRequest(req);
            await usageService.saveData();

            res.send(
              usageService.data
            );
          },
        ],
      }),

      new DyNTS_Endpoint_Params({
        name: 'updateUsage',
        type: DyFM_HttpCallType.post,
        endpoint: DyFM_usageModule_settings.endPoints.updateUsage,
        tasks: [
          async (req: Request, res: Response, issuer: string): Promise<void> => {
            const usageService = new DyNTS_Usage_DataService({
              usageSession: { _id: req.params.sessionId },
              usageData: req.body,
              issuer,
            });

            await usageService.updateUsageData(req);

            res.send(
              usageService.data
            );
          },
        ],
      }),

      new DyNTS_Endpoint_Params({
        name: 'closeSession',
        type: DyFM_HttpCallType.get,
        endpoint: DyFM_usageModule_settings.endPoints.closeSession,
        tasks: [
          async (req: Request, res: Response, issuer: string): Promise<void> => {
            const usageService = new DyNTS_Usage_DataService({
              usageSession: { _id: req.params.sessionId },
              issuer,
            });

            await usageService.closeSession(req);

            res.send(
              usageService.data
            );
          },
        ],
      }),

      new DyNTS_Endpoint_Params({
        name: 'getUsageData',
        type: DyFM_HttpCallType.get,
        endpoint: DyFM_usageModule_settings.endPoints.getUsageData,
        preProcesses: [ this.authService.authenticate_tokenPerm_accUsageData ],
        tasks: [
          async (req: Request, res: Response, issuer: string): Promise<void> => {
            const range: DyFM_RelativeDate = req.params.range as DyFM_RelativeDate;

            const usageService = new DyNTS_Usage_DataService({
              issuer: issuer,
            });

            await usageService.getUsage(range);

            res.send(
              usageService.simplifiedDailyUsage
            );
          },
        ],
      }),
    ];
  }
}