import { limitedLet } from 'limitedlet';

// Create a variable that can only be changed 3 times
const apiCalls = limitedLet(0, 3);

apiCalls.value = 1;   // ✅ First mutation
apiCalls.value = 2;   // ✅ Second mutation
apiCalls.value = 3;   // ✅ Third mutation
apiCalls.value = 4;   // ❌ Throws MutationLimitExceeded

import { limitedLet } from 'limitedlet';

// 🎯 Basic usage - single mutation allowed (default)
const setting = limitedLet('initial');
setting.value = 'updated';     // ✅
setting.value = 'again';       // ❌ Error

// 🔢 Multiple mutations with tracking
const counter = limitedLet(0, 5, {
  onMutate: ({ oldValue, newValue, remaining }) => {
    console.log(`${oldValue} → ${newValue}, ${remaining} left`);
  }
});

// 📊 Non-strict mode for behavioral analysis
const tracker = limitedLet('data', 2, {
  strictMode: false,  // Don't throw errors, just track
  onLimitExceeded: (attempt) => {
    analytics.track('quota_exceeded', {
      value: attempt.attemptedValue,
      attempt: attempt.attemptNumber
    });
  }
});

// 🎮 Complex objects and arrays
const gameState = limitedLet({ level: 1, lives: 3 }, 10);
const inventory = limitedLet(['sword'], 5);

// Properties (read-only)
variable.value           // Current value (get/set)
variable.remaining       // Mutations remaining
variable.mutationCount   // Successful mutations made
variable.violationCount  // Violation attempts (non-strict mode)
variable.maxMutations    // Maximum allowed mutations
variable.history         // Array of all changes (if tracking enabled)

// Methods
variable.isDepleted()    // true if all mutations used
variable.isFrozen()      // true if manually or auto-frozen
variable.freeze()        // Manually freeze variable
variable.reset()         // Reset mutation counter (if allowed)
variable.toString()      // String representation
variable.toJSON()        // JSON serialization

const loginAttempts = limitedLet(0, 3, {
  onLastMutation: () => {
    showMessage('Final login attempt - please be careful!');
  },
  onLimitExceeded: () => {
    // Redirect to help after 3 failed attempts
    window.location.href = '/forgot-password';
  }
});

async function handleLogin(credentials) {
  try {
    await authenticateUser(credentials);
    window.location.href = '/dashboard';
  } catch (error) {
    loginAttempts.value += 1;
    showError(`Login failed. ${loginAttempts.remaining} attempts remaining.`);
  }
}

const hintDialogs = limitedLet(0, 3, {
  onMutate: ({ newValue, remaining }) => {
    showHintDialog(`Tip #${newValue}: ${getTip(newValue)}`);
    if (remaining === 0) {
      showMessage('No more hints available. Check our documentation!');
    }
  },
  onLimitExceeded: () => {
    // Open documentation in new tab
    window.open('/docs/getting-started', '_blank');
  }
});

function showHint() {
  if (hintDialogs.isDepleted()) {
    showMessage('All hints used. Opening documentation...');
    window.open('/docs', '_blank');
  } else {
    hintDialogs.value += 1;
  }
}

const powerUps = limitedLet({ shields: 3, bombs: 2, speed: 1 }, 5, {
  onMutate: ({ newValue, remaining }) => {
    updateUI(newValue);
    if (remaining === 1) {
      showWarning('One power-up modification remaining!');
    }
  },
  onLastMutation: () => {
    achievement.unlock('POWER_MANAGER');
    showMessage('Power-up configuration locked for this level!');
  }
});

function upgradePowerUp(type) {
  if (!powerUps.isDepleted()) {
    powerUps.value = {
      ...powerUps.value,
      [type]: powerUps.value[type] + 1
    };
  } else {
    showMessage('Power-up upgrades locked! Complete level to reset.');
  }
}

const apiLimiter = limitedLet('ready', 10, {
  strictMode: false,  // Don't break the app
  onLimitExceeded: (attempt) => {
    // Switch to cached data after limit
    if (attempt.attemptNumber === 1) {
      showWarning('API limit reached. Using cached data.');
      enableCacheMode();
    }

    // Open docs after multiple violations
    if (attempt.attemptNumber >= 3) {
      window.open('/docs/api-limits', '_blank');
    }

    analytics.track('api_limit_exceeded', {
      endpoint: attempt.attemptedValue,
      total_attempts: attempt.totalAttempts
    });
  }
});

async function apiCall(endpoint) {
  if (!apiLimiter.isDepleted()) {
    apiLimiter.value = endpoint;
    return await fetch(endpoint);
  } else {
    // Use cached data or alternative approach
    return getCachedData(endpoint);
  }
}

const tracked = limitedLet('initial', 3, {
  trackHistory: true  // enabled by default
});

tracked.value = 'first';
tracked.value = 'second';
tracked.value = 'third';

console.log(tracked.history);
// [
//   { value: 'initial', timestamp: 1640995200000, mutation: 0, type: 'initial' },
//   { value: 'first', previousValue: 'initial', timestamp: 1640995201000, mutation: 1, type: 'mutation' },
//   { value: 'second', previousValue: 'first', timestamp: 1640995202000, mutation: 2, type: 'mutation' },
//   { value: 'third', previousValue: 'second', timestamp: 1640995203000, mutation: 3, type: 'mutation' }
// ]

const complex = limitedLet('start', 2, {
  strictMode: false,  // Track violations without throwing
  allowReset: true,   // Enable reset capability
  trackHistory: true
});

complex.value = 'mutation1';
complex.value = 'mutation2';
complex.value = 'violation1';  // Tracked, not blocked
complex.reset();
complex.value = 'after-reset';

console.log(complex.history);
// [
//   { value: 'start', timestamp: ..., mutation: 0, type: 'initial' },
//   { value: 'mutation1', previousValue: 'start', mutation: 1, type: 'mutation' },
//   { value: 'mutation2', previousValue: 'mutation1', mutation: 2, type: 'mutation' },
//   { value: 'violation1', previousValue: 'mutation2', mutation: 2, type: 'violation' },
//   { value: 'violation1', timestamp: ..., mutation: 0, type: 'reset' },
//   { value: 'after-reset', previousValue: 'violation1', mutation: 1, type: 'mutation' }
// ]

const debugVar = limitedLet({ user: 'john', role: 'admin' }, 10, {
  trackHistory: true,
  onMutate: ({ newValue }) => {
    console.log('📝 State changed:', newValue);
    saveToDevTools(debugVar.history);
  }
});

// Later in development...
function timeTravel(stepBack = 1) {
  const history = debugVar.history;
  const targetState = history[history.length - 1 - stepBack];
  console.log('⏪ Time traveling to:', targetState);
  return targetState.value;
}

class UndoRedoManager {
  constructor(variable) {
    this.variable = variable;
    this.currentIndex = variable.history.length - 1;
  }

  undo() {
    if (this.currentIndex > 0) {
      this.currentIndex--;
      const prevState = this.variable.history[this.currentIndex];
      return prevState.value;
    }
    return null;
  }

  redo() {
    if (this.currentIndex < this.variable.history.length - 1) {
      this.currentIndex++;
      const nextState = this.variable.history[this.currentIndex];
      return nextState.value;
    }
    return null;
  }

  getTimeline() {
    return this.variable.history.map((entry, index) => ({
      ...entry,
      isCurrent: index === this.currentIndex,
      relativeTime: new Date(entry.timestamp).toLocaleTimeString()
    }));
  }
}

const document = limitedLet('Hello', 10, { trackHistory: true });
const undoRedo = new UndoRedoManager(document);

document.value = 'Hello World';
document.value = 'Hello World!';

console.log(undoRedo.undo());        // "Hello World"
console.log(undoRedo.undo());        // "Hello"
console.log(undoRedo.redo());        // "Hello World"
console.log(undoRedo.getTimeline()); // Full timeline with timestamps

const userActions = limitedLet(0, 5, {
  strictMode: false,
  trackHistory: true,
  onLimitExceeded: (attempt) => {
    // Analyze user patterns from history
    const patterns = analyzeUserBehavior(userActions.history);

    analytics.track('user_behavior_analysis', {
      session_id: getSessionId(),
      total_attempts: attempt.totalAttempts,
      violation_frequency: patterns.violationFrequency,
      time_between_actions: patterns.averageTimeBetween,
      action_sequence: patterns.actionSequence
    });
  }
});

function analyzeUserBehavior(history) {
  const mutations = history.filter(h => h.type === 'mutation');
  const violations = history.filter(h => h.type === 'violation');

  return {
    violationFrequency: violations.length / mutations.length,
    averageTimeBetween: calculateAverageTimeBetween(history),
    actionSequence: history.map(h => ({ type: h.type, value: h.value })),
    peakUsageTime: findPeakUsageHours(history)
  };
}

// Custom React hook with history integration
function useTrackedState(initialValue, maxMutations = 5) {
  const [variable] = useState(() =>
    limitedLet(initialValue, maxMutations, {
      trackHistory: true,
      onMutate: (event) => {
        // Send to React DevTools
        if (window.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
          window.__REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot(
            null,
            { memoizedState: event.newValue, history: variable.history }
          );
        }
      }
    })
  );

  return {
    value: variable.value,
    setValue: (newValue) => variable.value = newValue,
    history: variable.history,
    timeTravel: (index) => variable.history[index]?.value
  };
}

// Usage in component
function MyComponent() {
  const state = useTrackedState({ count: 0, name: 'demo' }, 8);

  return (
    <div>
      <button onClick={() => state.setValue({...state.value, count: state.value.count + 1})}>
        Increment ({state.value.count})
      </button>

      {/* Show history in development */}
      {process.env.NODE_ENV === 'development' && (
        <details>
          <summary>History ({state.history.length} entries)</summary>
          <pre>{JSON.stringify(state.history, null, 2)}</pre>
        </details>
      )}
    </div>
  );
}

// For production: disable history if not needed
const production = limitedLet(value, 10, {
  trackHistory: false  // Saves memory and improves performance
});

// For development: full tracking
const development = limitedLet(value, 10, {
  trackHistory: true,
  onMutate: (event) => console.log('🔄 Mutation:', event)
});

// 🔒 Strict Mode (Production) - Default
const production = limitedLet('config', 3, {
  strictMode: true,           // Throws errors on violations
  onViolation: (error) => {
    logger.error('Config violation', error);
    alertAdmin(error.context);
  }
});

// 📊 Non-Strict Mode (Tracking/Development)
const development = limitedLet('feature', 3, {
  strictMode: false,          // Track violations without throwing
  onLimitExceeded: (attempt) => {
    analytics.track('feature_overuse', {
      value: attempt.attemptedValue,
      user_id: getCurrentUser().id,
      timestamp: attempt.timestamp
    });
  }
});

// When strictMode: false, autoFreeze is automatically disabled
const tracker = limitedLet('value', 2, {
  strictMode: false,    // autoFreeze becomes false automatically
  onLimitExceeded: (attempt) => {
    // This will continue to fire even after limit exceeded
    console.log(`Violation ${attempt.attemptNumber} tracked`);
  }
});

// Manual control (advanced usage)
const manual = limitedLet('value', 2, {
  strictMode: true,
  autoFreeze: false,    // Manually disable auto-freeze
});

const constant = limitedLet('IMMUTABLE', 0);
console.log(constant.value);  // "IMMUTABLE"
constant.value = 'change';    // ❌ Throws immediately

// Perfect for configuration that should never change
const API_KEY = limitedLet(process.env.API_KEY, 0);

// Object mutations
const settings = limitedLet({ theme: 'dark', lang: 'en' }, 5);
settings.value = { ...settings.value, theme: 'light' };

// Array mutations
const tags = limitedLet(['javascript'], 3);
tags.value = [...tags.value, 'typescript'];
tags.value = tags.value.filter(tag => tag !== 'javascript');

// Nested structures
const user = limitedLet({
  profile: { name: 'John', age: 30 },
  preferences: { notifications: true }
}, 10);

user.value = {
  ...user.value,
  profile: { ...user.value.profile, age: 31 }
};

const num = limitedLet(42, 3);

// Arithmetic operations
console.log(num + 8);           // 50
console.log(num * 2);           // 84

// String coercion
console.log(`Value: ${num}`);   // "Value: 42"
console.log(String(num));       // "42"

// Boolean coercion
console.log(!!num);             // true

// Comparison
console.log(num == 42);         // true
console.log(num === 42);        // false (proxy object)
console.log(num.valueOf());     // 42

const resettable = limitedLet(0, 3, {
  allowReset: true,
  trackHistory: true
});

resettable.value = 1;
resettable.value = 2;
resettable.value = 3;
console.log(resettable.isDepleted());    // true

// Reset and continue
resettable.reset();
console.log(resettable.remaining);       // 3
console.log(resettable.history.length);  // 4 (includes reset entry)

resettable.value = 10;  // ✅ Works again

// Test mutation limits
const counter = limitedLet(0, 3);
assert.equal(counter.remaining, 3);

counter.value = 1;
assert.equal(counter.mutationCount, 1);
assert.equal(counter.remaining, 2);

// Test error throwing
assert.throws(() => {
  counter.value = 2;
  counter.value = 3;
  counter.value = 4;  // Should throw
}, MutationLimitExceeded);

// Test callback execution
let callbackFired = false;
const tracked = limitedLet('start', 1, {
  onLastMutation: () => { callbackFired = true; }
});
tracked.value = 'end';
assert.equal(callbackFired, true);

// Boolean values
const bool = limitedLet(true, 2);
bool.value = false;
bool.value = true;
assert.throws(() => bool.value = false);

// Null and undefined
const nullVar = limitedLet(null, 1);
nullVar.value = undefined;
assert.equal(nullVar.value, undefined);

// Arrays
const arr = limitedLet([1, 2], 2);
arr.value = [3, 4];
arr.value = [5, 6, 7];
assert.deepEqual(arr.value, [5, 6, 7]);

const historical = limitedLet(10, 2, { trackHistory: true });
historical.value = 20;
historical.value = 30;

const history = historical.history;
assert.equal(history.length, 3);
assert.equal(history[0].type, 'initial');
assert.equal(history[1].type, 'mutation');
assert.equal(history[2].value, 30);

// JSON serialization
const json = historical.toJSON();
assert.equal(json.value, 30);
assert.equal(json.mutationCount, 2);
assert.equal(json.remaining, 0);

// Disable history tracking for better performance
const fast = limitedLet(value, 10, {
  trackHistory: false
});

// Use frozen variables to prevent further mutations
const optimized = limitedLet(data, 5);
// ... perform mutations ...
optimized.freeze();  // No more mutation checking needed

// Batch operations for better performance
const batch = limitedLet([], 1);
batch.value = items.map(transform).filter(validate);  // Single mutation