import { CapabilityProps } from "contracts/capabilityContract";

export class CapabilityService {
  private capabilities: Map<
    string,
    Set<{
      source: string;
      capability: CapabilityProps<any>;
    }>
  > = new Map();

  private static instance: CapabilityService;

  private constructor() {}

  public static getInstance(): CapabilityService {
    if (!this.instance) {
      this.instance = new CapabilityService();
    }
    return this.instance;
  }

  private register(
    capabilityName: string,
    source: string,
    capability: CapabilityProps<any>,
  ) {
    const handlers = this.capabilities.get(capabilityName) || new Set();
    handlers.add({ source, capability });
  }

  private executeCapabilityMethod<T>(
    capabilityName: string,
    ...args: any[]
  ): Set<T> {
    const results = new Set<T>();
    const handlers = this.capabilities.get(capabilityName);

    if (handlers) {
      handlers.forEach(({ capability }) => {
        const methodFunction = capability["execute"];
        if (methodFunction) {
          methodFunction(...args)
            .then((data) => results.add(data as T))
            .catch((error) =>
              console.error(`Error executing method ${capabilityName}:`, error),
            );
        }
      });
    }
    return results;
  }

  private removeCapability(source: string) {
    this.capabilities.forEach((capability_s, capabilityName) => {
      const newHandlers = new Set(
        Array.from(capability_s).filter(
          (capability) => capability.source !== source,
        ),
      );
      this.capabilities.set(capabilityName, newHandlers);
    });
  }

  private removeCapabilitys(capability: string) {
    this.capabilities.delete(capability);
  }

  public validateCapability(capability: CapabilityProps<any>): boolean {
    if (!capability.name || !capability.execute) {
      return false;
    }

    const namePattern = /^[a-z][a-zA-Z0-9_]*$/;
    if (!namePattern.test(capability.name)) {
      return false;
    }

    return true;
  }
}