type SimpleType = string | number | boolean | symbol | null | undefined;
type OmitAttrMap<T extends object> = {
  [K in keyof T]?: T[K] extends SimpleType
    ? T[K] | ((value: T[K], obj: T) => boolean)
    : (value: T[K], obj: T) => boolean;
};

/**
 * Returns a shallow copy of the input object with certain properties omitted based on a provided rule map.
 *
 * Each entry in the `map` defines a rule for whether to omit a property from the result:
 * - If the property value is a simple type (string, number, etc.), the map can specify:
 *   - a literal value to match (if equal, the property is omitted)
 *   - a function `(value, obj) => boolean` that returns true if the property should be omitted
 * - If the property is a complex type (object or function), only a function is allowed in the map.
 *
 * @template T - The type of the input object
 * @param obj - The object to filter
 * @param map - A map defining which attributes to omit
 * @param deep - If true, performs a deep clone before omitting attributes; otherwise, a shallow copy.
 * @returns A new object with selected attributes removed
 * @throws TypeError if a non-function rule is provided for a complex property
 */
export function omitAttr<T extends Object>(
  obj: T,
  map: OmitAttrMap<T>
): Partial<T> {
  const result: Partial<T> = { ...obj };
  const isComplex = (value: any) =>
    typeof value === "function" ||
    (typeof value === "object" && value !== null);
  for (const key in map) {
    if (!obj.hasOwnProperty(key)) continue;
    if (typeof map[key] === "function") {
      if (map[key](obj[key], obj)) delete result[key];
      continue;
    }
    if (isComplex(obj[key]))
      throw new TypeError(`map[${key}] is not a function`);
    if (obj[key] === map[key]) delete result[key];
  }
  return result;
}

type AmendAttrMap<T extends Object> = {
  [K in keyof T]: T[K] extends SimpleType
    ? T[K] | ((obj: Partial<T>) => T[K])
    : (obj: Partial<T>) => T[K];
};

type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
};

/**
 * Completes a partial object by filling in missing attributes using a mapping of default values or generator functions.
 *
 * For each key in the `map`:
 * - If the property is missing or `undefined` in the input, it will be added to the result:
 *   - If the map entry is a function `(obj) => value`, the result is computed dynamically
 *   - If it's a constant value (for simple types), it is directly assigned
 *
 * @template T - The type of the resulting complete object
 * @param input - A partial version of the target object
 * @param map - A map of default values or functions to supply missing properties
 * @param deep - If true, performs a deep clone of the input object before amending
 * @returns A fully constructed object of type `T`
 */
export function amendAttr<T extends Object>(
  input: DeepPartial<T>,
  map: AmendAttrMap<T>
): T {
  const obj = input as Partial<T>;
  const result = { ...obj };
  for (const key in map) {
    if (key in obj && obj[key] !== undefined) continue;
    if (typeof map[key] === "function") result[key] = map[key](obj);
    else result[key] = map[key] as T[typeof key];
  }
  return result as T;
}