import type { Cloudly } from '../classes.cloudly.js';
import * as plugins from '../plugins.js';
import { DnsEntry } from './classes.dnsentry.js';

export class DnsManager {
  public typedrouter = new plugins.typedrequest.TypedRouter();
  public cloudlyRef: Cloudly;

  get db() {
    return this.cloudlyRef.mongodbConnector.smartdataDb;
  }

  public CDnsEntry = plugins.smartdata.setDefaultManagerForDoc(this, DnsEntry);

  constructor(cloudlyRef: Cloudly) {
    this.cloudlyRef = cloudlyRef;
    
    this.cloudlyRef.typedrouter.addTypedRouter(this.typedrouter);

    // Get all DNS entries
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_GetDnsEntries>(
        'getDnsEntries',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const dnsEntries = await this.CDnsEntry.getDnsEntries(
            reqArg.zone ? { zone: reqArg.zone } : undefined
          );

          return {
            dnsEntries: await Promise.all(
              dnsEntries.map((entry) => entry.createSavableObject())
            ),
          };
        }
      )
    );

    // Get DNS entry by ID
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_GetDnsEntryById>(
        'getDnsEntryById',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const dnsEntry = await this.CDnsEntry.getDnsEntryById(reqArg.dnsEntryId);
          if (!dnsEntry) {
            throw new Error(`DNS entry with id ${reqArg.dnsEntryId} not found`);
          }

          return {
            dnsEntry: await dnsEntry.createSavableObject(),
          };
        }
      )
    );

    // Create DNS entry
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_CreateDnsEntry>(
        'createDnsEntry',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          // Validate domain exists if domainId is provided
          if (reqArg.dnsEntryData.domainId) {
            const domain = await this.cloudlyRef.domainManager.CDomain.getDomainById(reqArg.dnsEntryData.domainId);
            if (!domain) {
              throw new Error(`Domain with id ${reqArg.dnsEntryData.domainId} not found`);
            }
            // Set the zone from the domain name
            reqArg.dnsEntryData.zone = domain.data.name;
          }

          const dnsEntry = await this.CDnsEntry.createDnsEntry(reqArg.dnsEntryData);

          return {
            dnsEntry: await dnsEntry.createSavableObject(),
          };
        }
      )
    );

    // Update DNS entry
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_UpdateDnsEntry>(
        'updateDnsEntry',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          // Validate domain exists if domainId is provided
          if (reqArg.dnsEntryData.domainId) {
            const domain = await this.cloudlyRef.domainManager.CDomain.getDomainById(reqArg.dnsEntryData.domainId);
            if (!domain) {
              throw new Error(`Domain with id ${reqArg.dnsEntryData.domainId} not found`);
            }
            // Set the zone from the domain name
            reqArg.dnsEntryData.zone = domain.data.name;
          }

          const dnsEntry = await this.CDnsEntry.updateDnsEntry(
            reqArg.dnsEntryId,
            reqArg.dnsEntryData
          );

          return {
            dnsEntry: await dnsEntry.createSavableObject(),
          };
        }
      )
    );

    // Delete DNS entry
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_DeleteDnsEntry>(
        'deleteDnsEntry',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const success = await this.CDnsEntry.deleteDnsEntry(reqArg.dnsEntryId);

          return {
            success,
          };
        }
      )
    );

    // Get DNS zones
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.dns.IRequest_Any_Cloudly_GetDnsZones>(
        'getDnsZones',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const zones = await this.CDnsEntry.getDnsZones();

          return {
            zones,
          };
        }
      )
    );
  }

  /**
   * Initialize the DNS manager
   */
  public async init() {
    console.log('DNS Manager initialized');
  }

  /**
   * Stop the DNS manager
   */
  public async stop() {
    console.log('DNS Manager stopped');
  }
}