const { define } = require('mnemonica');

// Define a type
const UserType = define('UserType', function (data) {
  Object.assign(this, data);
});

// Create an instance
const user = new UserType({ name: 'John', email: 'john@example.com' });

// Define a subtype
const AdminType = UserType.define('AdminType', function () {
  this.role = 'admin';
});

// Create nested instance (inherits from user)
const admin = new user.AdminType();
console.log(admin.name); // 'John' (inherited)
console.log(admin.role); // 'admin' (own property)

import { define, lookup } from 'mnemonica/module';

// Using a constructor function
const SomeType = define('SomeType', function (opts) {
  Object.assign(this, opts);
});

// Using a factory function
const AnotherType = define(() => {
  const AnotherTypeConstructor = function (opts) {
    Object.assign(this, opts);
  };
  AnotherTypeConstructor.prototype.description = 'SomeType Constructor';
  return AnotherTypeConstructor;
});

// Using a class
const ClassType = define(() => {
  class MyClass {
    constructor(opts) {
      Object.assign(this, opts);
    }
  }
  return MyClass;
});

// Define nested types
SomeType.define('SubType', function (opts) {
  this.other = opts.other;
}, {
  description: 'SomeSubType Constructor'
});

// Or using assignment
SomeType.SubType = function (opts) {
  this.other = opts.other;
};
SomeType.SubType.prototype = {
  description: 'SomeSubType Constructor'
};

const someInstance = new SomeType({
  some: 'arguments',
  data: 'necessary'
});

const subInstance = new someInstance.SubType({
  other: 'data needed'
});

// All properties are inherited
console.log(subInstance.some);   // 'arguments' (inherited)
console.log(subInstance.other);  // 'data needed' (own)

const extracted = subInstance.extract();
// Result: { data, description, other, some }

// Or use the standalone utility
const { utils: { extract } } = require('mnemonica');
const extracted2 = extract(subInstance);

const MyType = define('MyType', function (data) {
  Object.assign(this, data);
}, {
  strictChain: true,
  blockErrors: true
});

const { lookup } = require('mnemonica');
const SomeType = lookup('SomeType');
const SomeNestedType = lookup('SomeType.SomeNestedType');

const { apply } = require('mnemonica');
const subInstance = apply(parentInstance, SubType, ['arg1', 'arg2']);

const { call } = require('mnemonica');
const subInstance = call(parentInstance, SubType, 'arg1', 'arg2');

const { bind } = require('mnemonica');
const createSub = bind(parentInstance, SubType);
const subInstance = createSub('arg1', 'arg2');

const { registerHook } = require('mnemonica');

registerHook(MyType, 'preCreation', (hookData) => {
  console.log('Creating:', hookData.TypeName);
});

const { defaultTypes } = require('mnemonica');
const MyType = defaultTypes.MyType;

const { createTypesCollection } = require('mnemonica');
const myCollection = createTypesCollection();
const MyType = myCollection.define('MyType', function () {});

const { createTypesCollection } = require('mnemonica');

// Create isolated collection with custom config
const myCollection = createTypesCollection({
  strictChain: false,
  blockErrors: false,
  exposeInstanceMethods: false  // Hide instance methods for cleaner API
});

// Define types in isolation
const MyType = myCollection.define('MyType', function (data) {
  Object.assign(this, data);
});

// Collection-level hooks
myCollection.registerHook('preCreation', (opts) => {
  console.log('Creating in myCollection:', opts.TypeName);
});

// Look up types within the collection
const FoundType = myCollection.lookup('MyType');

const { getProps, setProps } = require('mnemonica');

const props = getProps(instance);
console.log(props.__type__, props.__args__);

// Set properties
setProps(instance, { __timestamp__: Date.now() });

const extracted = instance.extract();

const picked = instance.pick('email', 'password');
// or
const picked = instance.pick(['email', 'password']);

const immediateParent = instance.parent();
const specificParent = instance.parent('UserType');

const cloned = instance.clone;
// Note: For async constructors, use: await instance.clone

const forked = instance.fork();           // same args
const forkedWithNewArgs = instance.fork('new', 'args');
// Note: For async constructors, use: await instance.fork(...)

const dagInstance = instanceA.fork.call(instanceB, 'args');

const error = someInstance.exception(new Error('Something went wrong'));
throw error;

const siblingType = instance.sibling('OtherType');
const sibling = instance.sibling.OtherType;

const { utils } = require('mnemonica');

const { utils: { parse } } = require('mnemonica');
const parsed = parse(instance);

const merged = utils.merge(instanceA, instanceB, 'args');
// Note: For async constructors, use: await utils.merge(...)

const json = utils.toJSON(instance);

const constructors = utils.collectConstructors(instance, true);

MyType.registerHook('preCreation', (hookData) => {
  console.log('Creating:', hookData.TypeName);
});

defaultTypes.registerHook('postCreation', (hookData) => {
  console.log('Created:', hookData.inheritedInstance.constructor.name);
});

defaultTypes.registerFlowChecker((opts) => {
  console.log('Flow check:', opts.TypeName);
});

MyType.registerHook('postCreation', (hookData) => {
  // Throw custom error from hook
  hookData.throwModificationError(new Error('Custom hook error'));
});

const { errors } = require('mnemonica');

// Available error types:
errors.BASE_MNEMONICA_ERROR
errors.WRONG_TYPE_DEFINITION
errors.WRONG_INSTANCE_INVOCATION
errors.WRONG_MODIFICATION_PATTERN
errors.ALREADY_DECLARED
errors.TYPENAME_MUST_BE_A_STRING
errors.HANDLER_MUST_BE_A_FUNCTION
errors.WRONG_ARGUMENTS_USED
errors.WRONG_HOOK_TYPE
errors.MISSING_HOOK_CALLBACK
errors.MISSING_CALLBACK_ARGUMENT
errors.FLOW_CHECKER_REDEFINITION
errors.OPTIONS_ERROR
errors.WRONG_STACK_CLEANER

const error = instance.exception(new Error('Original error'));

// Properties:
error.originalError    // The original error
error.exceptionReason  // { methodName, ... }
error.BaseStack        // Base stack trace
error.parse()          // Parse the exception structure
error.extract()        // Extract properties from the exception

const { defineStackCleaner } = require('mnemonica');

// Add regex patterns to clean stack traces
defineStackCleaner(/node_modules\/some-package/);

const {
  SymbolParentType,              // Parent type symbol
  SymbolConstructorName,         // Constructor name symbol
  SymbolDefaultTypesCollection,  // Default collection symbol
  SymbolConfig,                  // Config symbol
  MNEMONICA,                     // Library name
  MNEMOSYNE                      // Collection identifier
} = require('mnemonica');

define('SomeType', function () {}, {
  strictChain: true,        // Only allow sub-instances from current type
  blockErrors: true,        // Disallow construction if error in prototype chain
  submitStack: false,       // Collect stack trace as __stack__ property
  awaitReturn: true,        // Ensure await new Constructor() returns value
  ModificationConstructor: fn,  // Custom modification constructor
  asClass: false,           // Force class mode (auto-detected by default)
  exposeInstanceMethods: true   // Expose instance methods (default: true for backward compatibility)
});

import { defaultTypes, SymbolConfig } from 'mnemonica';

defaultTypes[SymbolConfig].blockErrors = false;

const { utils: { parse } } = require('mnemonica');

const parsed = parse(instance);
// Returns: { name, props, self, proto, joint, parent, constructor }

const { getProps } = require('mnemonica');

const props = getProps(instance);
// props.__type__, props.__args__, props.__parent__, props.__subtypes__, etc.

const { defaultTypes } = require('mnemonica');

// List all types in default collection
const typeNames = [...defaultTypes.subtypes.keys()];

// List subtypes of a specific type
const myType = defaultTypes.MyType;
const subTypeNames = [...myType.subtypes.keys()];

// Check if a type exists
const hasType = defaultTypes.lookup('MyType') !== undefined;

const { getProps } = require('mnemonica');

// Walk up the inheritance chain
function traverseChain(instance) {
  const chain = [];
  let current = instance;
  
  while (current) {
    const props = getProps(current);
    if (!props) break;
    
    chain.push({
      typeName: props.__type__.TypeName,
      timestamp: props.__timestamp__,
      args: props.__args__
    });
    
    current = props.__parent__;
  }
  
  return chain;
}

const { lookup } = require('mnemonica');

// Always check if type exists before construction
const MyType = lookup('MyType');
if (MyType) {
  const instance = new MyType(data);
}

// For nested construction with proper error handling
try {
  const subInstance = new instance.SubType(data);
} catch (error) {
  // Handle WRONG_MODIFICATION_PATTERN if SubType not defined
  console.error('Subtype not available:', error.message);
}

const { getProps } = require('mnemonica');

function analyzeType(typeConstructor) {
  return {
    name: typeConstructor.TypeName,
    isSubType: typeConstructor.isSubType,
    subTypesCount: typeConstructor.subtypes?.size || 0,
    hasHooks: Object.keys(typeConstructor.hooks || {}).length > 0,
    config: typeConstructor.config
  };
}

const { createTypesCollection, defaultTypes } = require('mnemonica');

// Create isolated collection for testing
const testCollection = createTypesCollection({
  strictChain: false,
  blockErrors: false
});

// Define types in isolation
const TestType = testCollection.define('TestType', function () {});

// Register collection-level hooks
testCollection.registerHook('preCreation', (data) => {
  console.log('Creating in test collection:', data.TypeName);
});

const AsyncType = define('AsyncType', async function (data) {
  await someAsyncOperation();
  return Object.assign(this, { data });
});

// Usage
const asyncInstance = await new AsyncType('tada');

// Nested async types
const NestedAsync = AsyncType.define('NestedAsync', async function (data) {
  return Object.assign(this, { nestedData: data });
});

const nested = await new asyncInstance.NestedAsync('nested');

async (req, res) => {
  const result = await new UserTypeConstructor({
      email: req.body.email,
      password: req.body.password
    })
    .UserEntityValidate('valid sign')
    .WithoutPassword()
    .AsyncPushToStorage()
    .AsyncGetStorageResponse()
    .SyncValidateStorageData()
    .AsyncReplyToRequest(res);
};

// Combine with process, window, document, etc.
const usingProcessAsProto = Singletoned.call(process, {
  some: 'arguments'
});

// With React
import ReactDOM from "react-dom";
const ReactDOOMed = define("ReactDOOMed", function() {});
const usingReactAsProto = ReactDOOMed.call(ReactDOM);

// Fork from different parent
const dagInstance = instanceA.fork.call(instanceB, 'args');

// Or use merge utility
const { utils: { merge } } = require('mnemonica');
const merged = merge(instanceA, instanceB, 'args');