import { ClassChangesTracker, type TChange } from 'class-changes-tracker';

// --- Setup ---
interface IAddress {
  street: string;
  city: string;
}
interface IUser {
  id: number;
  name: string;
  address: IAddress;
  tags: string[];
}

const tracker = new ClassChangesTracker();

const user: IUser = {
  id: 1,
  name: 'John Doe',
  address: { street: '123 Main St', city: 'Anytown' },
  tags: ['a', 'b'],
};

// 1. Start tracking properties
tracker.startTrack(user, 'name');
tracker.startTrack(user, 'address'); // Uses default maxDepth = 3
tracker.startTrack(user, 'tags');

// 2. Make some changes
user.name = 'Jane Doe';
user.address.city = 'New City';
user.tags.push('c'); // Structural change (length differs)

// 3. Check for changes (without updating the baseline snapshot)
let changes: TChange[] = tracker.peekChanges();
console.log('Initial Changes:', changes);
/*
Output includes:
[
  { path: 'name', oldValue: 'John Doe', newValue: 'Jane Doe' },
  { path: 'address.city', oldValue: 'Anytown', newValue: 'New City' },
  // Structural changes are reported at the parent level
  { path: 'tags', oldValue: [ 'a', 'b' ], newValue: [ 'a', 'b', 'c' ] }
]
*/

// 4. Update the baseline snapshots to the current state
tracker.updateSnapshots();

// 5. Make more changes
user.name = 'Jane Smith';
user.address.street = '456 Side St';

// 6. Check for changes again
changes = tracker.peekChanges();
console.log('Changes after snapshot update:', changes);
/*
Output includes:
[
  // Compares against the updated snapshot ('Jane Doe')
  { path: 'name', oldValue: 'Jane Doe', newValue: 'Jane Smith' },
  { path: 'address.street', oldValue: '123 Main St', newValue: '456 Side St' }
]
*/

// 7. Update snapshots again if needed for future checks
tracker.updateSnapshots();

import { ClassChangesTracker, type TChange } from 'class-changes-tracker';

const depthTracker = new ClassChangesTracker();
const deepUser = { data: { level1: { level2: { level3: 'value' } } } };

// Start tracking 'data' with maxDepth = 2
depthTracker.startTrack(deepUser, 'data', 2);

// Modify a property at depth 3 (level1 -> level2 -> level3)
deepUser.data.level1.level2.level3 = 'new value';

const changes: TChange[] = depthTracker.peekChanges();
console.log('Depth Changes:', changes);
/*
Output:
[
  // Change is reported at the maxDepth level (path: 'data.level1.level2')
  {
    path: 'data.level1.level2',
    oldValue: { level3: 'value' },
    newValue: { level3: 'new value' }
  }
]
*/

import { ClassChangesTracker, type TChange } from 'class-changes-tracker';

// Example custom class
class CustomId {
  constructor(public id: string) {}
  equals(other: any): boolean { // Optional: helps lodash.isEqual
    return other instanceof CustomId && other.id === this.id;
  }
}

// Configure tracker to treat CustomId as an atomic value
const customTypeTracker = new ClassChangesTracker({
  treatAsValue: (value) => value instanceof CustomId,
});

const userWithCustomId = {
  id: 2,
  customId: new CustomId('id-001'),
};

customTypeTracker.startTrack(userWithCustomId, 'customId');

// Replace the CustomId instance entirely
userWithCustomId.customId = new CustomId('id-002');

const changes: TChange[] = customTypeTracker.peekChanges();
console.log('Custom Type Changes:', changes);
/*
Output:
[
  // Change reported directly on 'customId', not its internal 'id' property,
  // because CustomId is treated as a value.
  {
    path: 'customId',
    oldValue: CustomId { id: 'id-001' },
    newValue: CustomId { id: 'id-002' }
  }
]
*/

import { ClassChangesTracker } from 'class-changes-tracker';

const tracker = new ClassChangesTracker();
const user = { name: 'Temp User', id: 99 };

tracker.startTrack(user, 'name');
tracker.startTrack(user, 'id');

// Stop tracking only 'name'
tracker.stopTrack(user, 'name');
user.name = 'Final Name'; // This change won't be detected by peekChanges()

// Stop tracking everything
tracker.stopAllTracks();
user.id = 100; // This change won't be detected either

const changes = tracker.peekChanges();
console.log('Changes after stopping:', changes); // Output: []