import * as plugins from '../../plugins.js';
import type { OpsServer } from '../classes.opsserver.js';

export class WebPushAppHandler {
  public typedrouter = new plugins.typedrequest.TypedRouter();

  public constructor(private readonly opsServerRef: OpsServer) {
    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
    this.registerHandlers();
  }

  private registerHandlers(): void {
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<
        plugins.servezoneInterfaces.requests.webpush.IReq_GetWebPushServiceStatus
      >(
        'getWebPushServiceStatus',
        async (dataArg) => {
          const manager = this.opsServerRef.dcRouterRef.webPushManager;
          if (!manager.isReady) return manager.getUnavailableServiceStatus();
          return await manager.getServiceStatus(dataArg.auth);
        },
      ),
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<
        plugins.servezoneInterfaces.requests.webpush.IReq_EnqueueWebPush
      >(
        'enqueueWebPush',
        async (dataArg) => {
          try {
            return await this.opsServerRef.dcRouterRef.webPushManager.enqueue(
              dataArg.auth,
              {
                idempotencyKey: dataArg.idempotencyKey,
                subscriptionId: dataArg.subscriptionId,
                subscription: dataArg.subscription,
                vapidKeyId: dataArg.vapidKeyId,
                payload: dataArg.payload,
                ttlSeconds: dataArg.ttlSeconds,
                urgency: dataArg.urgency,
                collapseKey: dataArg.collapseKey,
              },
            );
          } catch (error: unknown) {
            return {
              accepted: false,
              message: this.safeMessage(error),
            };
          }
        },
      ),
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<
        plugins.servezoneInterfaces.requests.webpush.IReq_CancelWebPush
      >(
        'cancelWebPush',
        async (dataArg) => {
          try {
            const result = await this.opsServerRef.dcRouterRef.webPushManager.cancel(
              dataArg.auth,
              dataArg.target,
            );
            return {
              success: true,
              ...result,
            };
          } catch (error: unknown) {
            return {
              success: false,
              cancelledCount: 0,
              alreadyTerminalCount: 0,
              message: this.safeMessage(error),
            };
          }
        },
      ),
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<
        plugins.servezoneInterfaces.requests.webpush.IReq_GetWebPushDeliveryStatus
      >(
        'getWebPushDeliveryStatus',
        async (dataArg) => {
          return {
            delivery: await this.opsServerRef.dcRouterRef.webPushManager.getDeliveryStatus(
              dataArg.auth,
              dataArg.spoolItemId,
            ),
          };
        },
      ),
    );
  }

  private safeMessage(errorArg: unknown): string {
    return errorArg instanceof plugins.typedrequest.TypedResponseError
      ? errorArg.message
      : 'Web Push delivery operation failed';
  }
}