import { Assertion } from '../smartexpect.classes.assertion.js';
import type { TExecutionType } from '../types.js';

/**
 * Namespace for function-specific matchers
 */
export class FunctionMatchers<M extends TExecutionType> {
  constructor(private assertion: Assertion<Function, M>) {}

  toThrow(expectedError?: any) {
    return this.assertion.customAssertion(
      (value) => {
        let threw = false;
        try {
          (value as Function)();
        } catch (e: any) {
          threw = true;
          if (expectedError) {
            if (typeof expectedError === 'function') {
              return e instanceof expectedError;
            }
            return e === expectedError;
          }
        }
        return threw;
      },
      `Expected function to throw${expectedError ? ` ${expectedError}` : ''}`
    );
  }
  /**
   * Assert thrown error message matches the given regex
   */
  toThrowErrorMatching(regex: RegExp) {
    return this.assertion.customAssertion(
      (value) => {
        try {
          (value as Function)();
        } catch (e: any) {
          return regex.test(e && e.message);
        }
        return false;
      },
      `Expected function to throw error matching ${regex}`
    );
  }
  /**
   * Assert thrown error message equals the given string
   */
  toThrowErrorWithMessage(expectedMessage: string) {
    return this.assertion.customAssertion(
      (value) => {
        try {
          (value as Function)();
        } catch (e: any) {
          return e && e.message === expectedMessage;
        }
        return false;
      },
      `Expected function to throw error with message "${expectedMessage}"`
    );
  }
}