import { isPlainObject, isAsync, inject, newFunction } from 'util-ex'

// Type checking
console.log(isPlainObject({})) // true
console.log(isPlainObject([])) // false

// Async function detection
async function myAsyncFunc() {}
console.log(isAsync(myAsyncFunc)) // true

// Function injection
const originalFunc = (a, b) => a + b
const beforeFunc = (a, b) => console.log(`Adding ${a} + ${b}`)
const afterFunc = (result) => {
  console.log(`Result: ${result}`)
  return result * 2
}
const wrappedFunc = inject(originalFunc, beforeFunc, afterFunc)
console.log(wrappedFunc(2, 3)) // Logs: Adding 2 + 3, Result: 5, Returns: 10

// Dynamic function creation
const adder = newFunction('adder', ['a', 'b'], 'return a + b')
console.log(adder(2, 3)) // 5

import { inject as injectFunc } from 'util-ex'

// Wrapping a function with injectFunc
const originalFunc = (a, b) => a + b;
const beforeFunc = (a, b) => console.log(`Before execution: a = ${a}, b = ${b}`);
const afterFunc = (result) => console.log(`After execution: result = ${result}`);
const wrappedFunc = injectFunc(originalFunc, beforeFunc, afterFunc);
const result = wrappedFunc(1, 2); // Logs "Before execution: a = 1, b = 2" and "After execution: result = 3"

// Wrapping a function with injectFunc and modifying arguments and return value
const Arguments = injectFunc.Arguments
const originalFunc = (a, b) => a + b;
const beforeFunc = (a, b) => {
  console.log(`Before execution: a = ${a}, b = ${b}`);
  return new Arguments([a * 2, b * 3]);
};
const afterFunc = (result, isDenied) => {
  console.log(`After execution: result = ${result}, isDenied = ${isDenied}`);
  return result * 2;
};
const wrappedFunc = injectFunc(originalFunc, beforeFunc, afterFunc);
const result = wrappedFunc(1, 2); // Logs "Before execution: a = 1, b = 2", "After execution: result = 6, isDenied = false"
console.log(result); // Output: 12

// Wrapping a function with injectFunc and not executing the original function
const originalFunc = (a, b) => a + b;
const beforeFunc = (a, b) => {
  console.log(`Before execution: a = ${a}, b = ${b}`);
  return "Not executing original function";
};
const afterFunc = (result, isDenied) => {
  console.log(`After execution: result = ${result}, isDenied = ${isDenied}`);
  return "Modified return value";
};
const wrappedFunc = injectFunc(originalFunc, beforeFunc, afterFunc);
const result = wrappedFunc(1, 2); // Logs "Before execution: a = 1, b = 2", "After execution: result = Modified return value, isDenied = true"
console.log(result); // Output: "Modified return value"

// Wrapping a function with injectFunc and getting the original function's error
const originalFunc = () => {
  throw new Error("Original function error");
};
const beforeFunc = () => {
  console.log("Before execution");
};
const afterFunc = (result, isDenied) => {
  console.log(`After execution: result = ${result}, isDenied = ${isDenied}`);
};
const wrappedFunc = injectFunc(originalFunc, beforeFunc, afterFunc);
wrappedFunc(); // Logs "Before execution", "After execution: result = [Error: Original function error], isDenied = false"

import { newFunction } from 'util-ex'

var fn = newFunction('yourFuncName', ['arg1', 'arg2'], 'return log(arg1+arg2);', {log:console.log})
newFunction('function yourFuncName(){}')
newFunction('function yourFuncName(arg1, arg2){return log(arg1+arg2);}', {log:console.log})
newFunction('function yourFuncName(arg1, arg2){return log(arg1+arg2);}', ['log'], [console.log])

//fn.toString() is :
/*
 "function yourFuncName(arg1, arg2) {
    return log(arg1+arg2);
 }"
*/

import { newScopedFunction } from 'util-ex'
// Basic usage
const scopedFunc = newScopedFunction(
  'add',
  ['x'],
  'return x + y',
  { y: 10 } // Initial scope
);
scopedFunc(5); // Returns 15

// Dynamic scope update
const scope = { y: 20 };
const updatableFunc = newScopedFunction('add', ['x'], 'return x + y', scope);
updatableFunc(5); // Returns 25
scope.y = 100;
updatableFunc(5); // Returns 105

import { isAsync } from 'util-ex'

async function myAsyncFunc() {}
isAsync(myAsyncFunc) // true
isAsync(Promise.resolve()) // true
isAsync(() => {}) // false

import { isPatternMatched } from 'util-ex'

// RegExp pattern matching
isPatternMatched("hello world", /hello/); // true

// String pattern with strict equality
isPatternMatched("test", "test"); // true
isPatternMatched("test", "testing"); // false

// String pattern with inclusion check
isPatternMatched("hello world", "world", true); // true

// RegExp string pattern
isPatternMatched("123", "/\\d+/"); // true

const defineProperty = require('util-ex/lib/defineProperty')

let propValue = ''
const obj = {}

defineProperty(obj, 'prop', 'simpleValue')
defineProperty(obj, 'prop', undefined, {
  get() {return propValue}
  set(value) {propValue = value}
})