@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

package/src/lib/services/storage.service.ts

@@ -1,729 +0,0 @@
-import { Injectable } from '@angular/core';
-import { LocalStorageService } from 'ngx-webstorage';
-import { filter, Subscription } from 'rxjs';
-import { CodeEditorLanguages } from '../components/code-editor/helpers/code-editor-helper.model';
-import { AutoSavedData, AutoSavedDataV1, AutoSavedDataV2, QuestionData, TestData } from '../models/auto-saved-data';
-import { Config } from '../models/configs';
-import { AssessmentIdPreview } from '../models/lat-languages';
-import { Modes } from '../models/mode';
-import { CustomTestCase, ExampleTestCase } from '../models/test-cases';
-import { ConfigurationsService } from './configurations.service';
-import { LibCodingTestService } from './lib-coding-test.service';
-import { timeToMs } from '../utils/time-to-ms.util';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class StorageCodingService {
-  private readonly CURRENT_STORAGE_VERSION = 2;
-  private autoSavedData: AutoSavedData = {
-    version: this.CURRENT_STORAGE_VERSION,
-    config: {} as Config,
-    isFullscreen: false,
-    assessments: {},
-    lastModified: Date.now(),
-  };
-  private readonly key = 'savedData';
-  private assessmentId: string;
-  private questionId: string;
-  private language: CodeEditorLanguages;
-  private codeSaveEnabled: boolean;
-  private testCasesSaveEnabled: boolean;
-  private isLAT: boolean;
-  private currentMode: Modes;
-  private isPreview: boolean;
-  private codeChangeSubscription: Subscription;
-  private configSubscription: Subscription;
-  private isFullscreenSubscription: Subscription;
-  private currentLanguageSubscription: Subscription;
-  private isCodeComponentAlive = filter(() => !this.configurationsService.getCodeComponentDestroyed());
-
-  // Maximum age of entire storage data in days
-  private readonly MAX_STORAGE_AGE_DAYS = 7;
-  // Maximum age for assessment inner data in days
-  private readonly MAX_QUESTION_DATA_AGE_DAYS = 1;
-  // Maximum number of assessments to keep
-  private readonly MAX_ASSESSMENTS = 10;
-  // The default question ID used for migrated v1 data
-  private readonly DEFAULT_MIGRATION_QUESTION_ID = 'default-question';
-
-  // todo: remove
-  // storage = {
-  //   retrieve: (key: string) => {
-  //     return {} as any;
-  //   },
-  //   store: (key: string, value: any) => {
-  //     return {} as any;
-  //   },
-  //   clear: (key: string) => {
-  //     return {} as any;
-  //   },
-  // };
-
-  constructor(
-    // todo
-    private storage: LocalStorageService,
-    private libCodingTestService: LibCodingTestService,
-    private configurationsService: ConfigurationsService
-  ) {
-    // Perform safety check on localStorage data
-    this.performStorageSafetyCheck();
-  }
-
-  /**
-   * Performs a safety check on localStorage data.
-   * This is called at service initialization to ensure data integrity.
-   */
-  private performStorageSafetyCheck(): void {
-    try {
-      const savedData = this.storage.retrieve(this.key);
-
-      // If no data, nothing to check
-      if (!savedData) {
-        return;
-      }
-
-      // Check storage format and migrate if needed
-      if (!('version' in savedData)) {
-        // It's v1 format, so we'll migrate it when it's actually needed
-        // No need to do anything right now
-      } else {
-        // It's v2 format, so we can perform cleanup right away
-        this.autoSavedData = savedData as AutoSavedData;
-      }
-    } catch (error) {
-      // If any error occurs during safety check, reset storage to avoid issues
-      console.error('Error during storage safety check, resetting storage:', error);
-      this.autoSavedData = {
-        version: this.CURRENT_STORAGE_VERSION,
-        config: {} as Config,
-        isFullscreen: false,
-        assessments: {},
-        lastModified: Date.now(),
-      };
-      this.storeData();
-    }
-  }
-
-  initializeSaving(): void {
-    if (!this.codeChangeSubscription) {
-      this.codeChangeSubscription = this.libCodingTestService.codeChange$
-        .pipe(this.isCodeComponentAlive)
-        .subscribe((code: string) => {
-          if (this.codeSaveEnabled && this.assessmentId && this.questionId) {
-            this.ensureDataStructure();
-            const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
-            const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
-            targetTestData.code[this.language] = code!;
-            this.updateLastModified(targetTestData);
-            this.storeData();
-          }
-        });
-    }
-
-    if (!this.configSubscription) {
-      this.configSubscription = this.configurationsService.config$
-        .pipe(this.isCodeComponentAlive)
-        .subscribe((config: Config) => {
-          this.autoSavedData.config = { ...config };
-          this.updateLastModified(this.autoSavedData);
-          this.storeData();
-        });
-    }
-
-    if (!this.isFullscreenSubscription) {
-      this.isFullscreenSubscription = this.libCodingTestService.isFullscreen$
-        .pipe(this.isCodeComponentAlive)
-        .subscribe((isFullscreen: boolean) => {
-          this.autoSavedData.isFullscreen = isFullscreen;
-          this.updateLastModified(this.autoSavedData);
-          this.storeData();
-        });
-    }
-
-    if (!this.currentLanguageSubscription && this.isLAT) {
-      this.currentLanguageSubscription = this.libCodingTestService.currentLanguage$
-        .pipe(this.isCodeComponentAlive)
-        .subscribe((language: CodeEditorLanguages) => {
-          this.autoSavedData.lastLanguageLAT = {
-            value: language,
-            version: this.libCodingTestService.getVersion(),
-          };
-          this.updateLastModified(this.autoSavedData);
-          this.storeData();
-        });
-    }
-  }
-
-  setupAutoSavedData(
-    language: CodeEditorLanguages,
-    assessmentId: string,
-    questionId: string,
-    codeSaveEnabled: boolean,
-    testCasesSaveEnabled: boolean,
-    isLAT: boolean,
-    mode: Modes
-  ) {
-    this.language = language;
-    this.assessmentId = assessmentId;
-    this.questionId = questionId;
-    this.codeSaveEnabled = codeSaveEnabled;
-    this.testCasesSaveEnabled = testCasesSaveEnabled;
-    this.isLAT = isLAT;
-    this.currentMode = mode;
-    this.isPreview = mode === Modes.Preview || mode === Modes.NonAssessmentPreview;
-
-    // Get saved data
-    const savedData = this.storage.retrieve(this.key);
-
-    // Handle migration if needed
-    if (savedData) {
-      // Check if it's v1 schema (no version field)
-      if (!('version' in savedData)) {
-        this.migrateFromV1ToV2(savedData as AutoSavedDataV1);
-      } else {
-        this.autoSavedData = savedData as AutoSavedData;
-      }
-
-      // Apply loaded config and fullscreen setting
-      this.configurationsService.setConfig(this.autoSavedData.config);
-      this.libCodingTestService.setFullscreen(this.autoSavedData.isFullscreen);
-    }
-  }
-
-  private migrateFromV1ToV2(v1Data: AutoSavedDataV1): void {
-    // Create a new v2 data structure
-    const v2Data: AutoSavedDataV2 = {
-      version: this.CURRENT_STORAGE_VERSION,
-      config: v1Data.config,
-      isFullscreen: v1Data.isFullscreen,
-      lastLanguageLAT: v1Data.lastLanguageLAT,
-      assessments: {},
-      lastModified: Date.now(),
-    };
-
-    // Migrate assessment data
-    // In v1, assessments were directly mapped to TestData
-    // In v2, we need to organize by questionId
-    for (const [assessmentId, testData] of Object.entries(v1Data.assessments)) {
-      if (assessmentId === AssessmentIdPreview) {
-        continue;
-      }
-
-      // We use a consistent default questionId for migration to ensure backward compatibility
-      const defaultQuestionId = this.DEFAULT_MIGRATION_QUESTION_ID;
-
-      // Initialize the assessment entry if it doesn't exist
-      if (!v2Data.assessments[assessmentId]) {
-        v2Data.assessments[assessmentId] = {};
-      }
-
-      // Create question data with the migrated test data
-      const questionData: QuestionData = {};
-
-      questionData.actual = {
-        ...testData,
-        lastModified: Date.now(),
-      };
-
-      // Set last modified time for the question data
-      questionData.lastModified = Date.now();
-
-      // Add to the v2 structure
-      v2Data.assessments[assessmentId][defaultQuestionId] = questionData;
-    }
-
-    // Update our instance with migrated data
-    this.autoSavedData = { ...v2Data };
-
-    // Save the migrated data
-    this.storeData();
-  }
-
-  private ensureDataStructure(): void {
-    // Make sure assessment exists
-    if (!this.autoSavedData.assessments[this.assessmentId]) {
-      this.autoSavedData.assessments[this.assessmentId] = {};
-    }
-
-    // Make sure question exists
-    if (!this.autoSavedData.assessments[this.assessmentId][this.questionId]) {
-      this.autoSavedData.assessments[this.assessmentId][this.questionId] = {
-        lastModified: Date.now(),
-      };
-    }
-
-    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
-
-    // Ensure preview or actual exists based on current mode
-    if (this.isPreview && !questionData.preview) {
-      questionData.preview = {
-        code: {},
-        testCasesLAT: [],
-        lastModified: Date.now(),
-      };
-    } else if (!this.isPreview && !questionData.actual) {
-      questionData.actual = {
-        code: {},
-        testCasesLAT: [],
-        lastModified: Date.now(),
-      };
-    }
-  }
-
-  private updateLastModified(data: TestData | QuestionData | AutoSavedData): void {
-    const now = Date.now();
-    data.lastModified = now;
-
-    // If updating a TestData, also update its parent QuestionData
-    if ('code' in data && this.assessmentId && this.questionId) {
-      this.autoSavedData.assessments[this.assessmentId][this.questionId].lastModified = now;
-    }
-
-    // Always update root timestamp regardless of the object being modified
-    this.autoSavedData.lastModified = now;
-  }
-
-  /**
-   * Cleanup with a temporary age threshold
-   * @param maxAgeDays Maximum age in days for data to be considered valid
-   */
-  private cleanupWithReducedThreshold(maxAgeDays: number): void {
-    // Call the unified cleanup method with more aggressive parameters
-    this.cleanupStorageData({
-      storageAgeMultiplier: 2, // More aggressive multiplier
-      customStorageAgeDays: maxAgeDays, // Use the provided custom age
-      minQuestionDataAgeDays: 0.5, // 12 hours minimum
-      assessmentLimitMultiplier: 0.5, // Half the normal assessment limit
-    });
-  }
-
-  /**
-   * Unified method to clean up localStorage data with configurable intensity
-   * @param options Cleanup options to control the aggressiveness of the cleanup
-   */
-  private cleanupStorageData(options: {
-    storageAgeMultiplier?: number; // Multiplier for storage age threshold (default: 1)
-    customStorageAgeDays?: number; // Custom storage age in days (overrides MAX_STORAGE_AGE_DAYS if provided)
-    useStandardQuestionDataAge?: boolean; // Whether to use standard question data age (default: false)
-    minQuestionDataAgeDays?: number; // Minimum age for question data in days (default: 0.5 - 12 hours)
-    assessmentLimitMultiplier?: number; // Multiplier for maximum assessments (default: 1)
-  }): void {
-    const now = Date.now();
-
-    // Determine the storage age threshold
-    const storageAgeDays = options.customStorageAgeDays ?? this.MAX_STORAGE_AGE_DAYS;
-    const storageAgeThreshold = timeToMs(storageAgeDays); // Convert days to milliseconds
-    const multiplier = options.storageAgeMultiplier ?? 1;
-
-    // Check if the entire storage is too old and needs cleanup
-    if (this.autoSavedData.lastModified && now - this.autoSavedData.lastModified > storageAgeThreshold * multiplier) {
-      // If the entire storage is very old, just reset everything
-      this.autoSavedData = {
-        version: this.CURRENT_STORAGE_VERSION,
-        config: this.autoSavedData.config, // Keep the config settings
-        isFullscreen: this.autoSavedData.isFullscreen, // Keep fullscreen setting
-        assessments: {},
-        lastModified: now,
-      };
-      this.storeData();
-      return;
-    }
-
-    // Structure for collecting assessment data with metadata
-    interface AssessmentMetadata {
-      id: string;
-      lastModified: number;
-    }
-
-    const assessmentMetadata: AssessmentMetadata[] = [];
-
-    // Determine the question data age threshold
-    let questionDataAgeThreshold: number;
-    if (options.useStandardQuestionDataAge) {
-      // Use the standard threshold for normal cleanup
-      questionDataAgeThreshold = timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS);
-    } else {
-      // For maintenance/aggressive cleanup, use a custom threshold
-      const minAgeHours = (options.minQuestionDataAgeDays ?? 0.5) * 24; // Convert days to hours
-      questionDataAgeThreshold = Math.max(
-        timeToMs(this.MAX_QUESTION_DATA_AGE_DAYS), // Standard age in milliseconds
-        timeToMs(minAgeHours, 'hours') // Minimum age in milliseconds
-      );
-    }
-
-    // Collect assessments with their latest modification times
-    for (const [assessmentId, questions] of Object.entries(this.autoSavedData.assessments)) {
-      let assessmentLastModified = 0;
-
-      // Check all questions in this assessment
-      let hasValidQuestions = false;
-
-      for (const [questionId, questionData] of Object.entries(questions)) {
-        // Skip if undefined
-        if (!questionData) {
-          continue;
-        }
-
-        // Get the latest modification time from preview and actual
-        const previewTime = questionData.preview?.lastModified || 0;
-        const actualTime = questionData.actual?.lastModified || 0;
-        const questionLastModified = Math.max(previewTime, actualTime, questionData.lastModified || 0);
-
-        // Check if data is too old - using configured threshold
-        const isPreviewTooOld = previewTime > 0 && now - previewTime > questionDataAgeThreshold;
-        const isActualTooOld = actualTime > 0 && now - actualTime > questionDataAgeThreshold;
-
-        // Clean up old data within the question
-        if (isPreviewTooOld && questionData.preview) {
-          delete questionData.preview;
-        }
-
-        if (isActualTooOld && questionData.actual) {
-          delete questionData.actual;
-        }
-
-        // If neither preview nor actual exists, remove the question
-        if (!questionData.preview && !questionData.actual) {
-          delete questions[questionId];
-        } else {
-          hasValidQuestions = true;
-          assessmentLastModified = Math.max(assessmentLastModified, questionLastModified);
-        }
-      }
-
-      // If no valid questions, remove the assessment
-      if (!hasValidQuestions) {
-        delete this.autoSavedData.assessments[assessmentId];
-      } else {
-        // Add to our list for potential size-based cleanup
-        assessmentMetadata.push({
-          id: assessmentId,
-          lastModified: assessmentLastModified,
-        });
-      }
-    }
-
-    // Determine the assessment limit based on the multiplier
-    const limitMultiplier = options.assessmentLimitMultiplier ?? 1;
-    const assessmentLimit = Math.ceil(this.MAX_ASSESSMENTS * limitMultiplier);
-
-    // If we have too many assessments, remove the oldest ones
-    if (assessmentMetadata.length > assessmentLimit) {
-      // Sort by lastModified (most recent first)
-      assessmentMetadata.sort((a, b) => b.lastModified - a.lastModified);
-
-      // Remove oldest assessments that exceed our limit
-      for (let i = assessmentLimit; i < assessmentMetadata.length; i++) {
-        delete this.autoSavedData.assessments[assessmentMetadata[i].id];
-      }
-    }
-
-    // Save the cleaned data
-    this.storeData();
-  }
-
-  changeLanguage(language: CodeEditorLanguages) {
-    this.language = language;
-  }
-
-  /**
-   * Gets data from v1 schema format
-   * Used for backward compatibility when retrieving data
-   */
-  private getDataFromV1Schema(retrievedData: AutoSavedDataV1): string | (ExampleTestCase | CustomTestCase)[] | null | undefined {
-    // For v1, we need to handle the case where we don't have questionId
-    // We're now using questionId in the app, but stored data might still be in v1 format
-
-    // For preview data, the assessment ID would be AssessmentIdPreview
-    if (this.assessmentId === AssessmentIdPreview) {
-      if (this.isPreview) {
-        // For preview mode on preview assessment, get the code directly
-        const code = retrievedData.assessments[this.assessmentId]?.code;
-        if (code && this.language in code) {
-          return code[this.language];
-        }
-      }
-      // We don't expect actual/non-preview data for AssessmentIdPreview
-      return null;
-    } else {
-      // For regular assessments, v1 only had code in the "actual" section
-      if (!this.isPreview) {
-        const code = retrievedData.assessments[this.assessmentId]?.code;
-        if (code && this.language in code) {
-          return code[this.language];
-        }
-      }
-      // We don't have preview data for regular assessments in v1
-      return null;
-    }
-  }
-
-  getSavedCode(): string | null | undefined {
-    const retrievedData = this.retrieveData();
-    if (!retrievedData) {
-      return null;
-    }
-
-    // Check if using v2 schema
-    if ('version' in retrievedData) {
-      // Handle v2 schema
-      const v2Data = retrievedData;
-      const assessmentData = v2Data.assessments[this.assessmentId];
-
-      if (!assessmentData) {
-        return null;
-      }
-
-      // First try with provided questionId
-      if (this.questionId && assessmentData[this.questionId]) {
-        const questionData = assessmentData[this.questionId];
-        const testData = this.isPreview ? questionData.preview : questionData.actual;
-        if (testData?.code && this.language in testData.code) {
-          return testData.code[this.language];
-        }
-      }
-
-      if (
-        this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&
-        assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]
-      ) {
-        const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];
-        const testData = this.isPreview ? questionData.preview : questionData.actual;
-        if (testData?.code && this.language in testData.code) {
-          return testData.code[this.language];
-        }
-      }
-
-      return null;
-    } else {
-      // Handle v1 schema for backward compatibility
-      return this.getDataFromV1Schema(retrievedData) as string;
-    }
-  }
-
-  getLastLanguageLAT(): {
-    value: CodeEditorLanguages;
-    version: string;
-  } | null {
-    const retrievedData = this.retrieveData();
-    if (!retrievedData) {
-      return null;
-    }
-
-    return retrievedData.lastLanguageLAT || null;
-  }
-
-  getSavedTestCases(): (ExampleTestCase | CustomTestCase)[] | null | undefined {
-    const retrievedData = this.retrieveData();
-    if (!retrievedData) {
-      return null;
-    }
-
-    // Check if using v2 schema
-    if ('version' in retrievedData) {
-      // Handle v2 schema
-      const v2Data = retrievedData;
-      const assessmentData = v2Data.assessments[this.assessmentId];
-
-      if (!assessmentData) {
-        return null;
-      }
-
-      // First try with provided questionId
-      if (this.questionId && assessmentData[this.questionId]) {
-        const questionData = assessmentData[this.questionId];
-        const testData = this.isPreview ? questionData.preview : questionData.actual;
-        if (testData?.testCasesLAT) {
-          return testData.testCasesLAT;
-        }
-      }
-
-      // If not found and questionId != DEFAULT_MIGRATION_QUESTION_ID,
-      // also try with the default migration ID as a fallback
-      if (
-        this.questionId !== this.DEFAULT_MIGRATION_QUESTION_ID &&
-        assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID]
-      ) {
-        const questionData = assessmentData[this.DEFAULT_MIGRATION_QUESTION_ID];
-        const testData = this.isPreview ? questionData.preview : questionData.actual;
-        if (testData?.testCasesLAT) {
-          return testData.testCasesLAT;
-        }
-      }
-
-      return null;
-    } else {
-      // Handle v1 schema test cases (test cases were only in the actual mode)
-      const v1Data = retrievedData;
-      if (!this.isPreview && v1Data.assessments[this.assessmentId]?.testCasesLAT) {
-        return v1Data.assessments[this.assessmentId].testCasesLAT;
-      }
-      return null;
-    }
-  }
-
-  getSavedConfig(): Config | null {
-    const retrievedData = this.retrieveData();
-    return retrievedData?.config ? { ...retrievedData.config } : null;
-  }
-
-  getSavedFullScreenMode(): boolean | null {
-    const retrievedData = this.retrieveData();
-    return retrievedData?.isFullscreen !== undefined ? retrievedData.isFullscreen : null;
-  }
-
-  clearSavedCode(): void {
-    this.ensureDataStructure();
-    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
-    const targetTestData = this.isPreview ? [questionData.preview] : [questionData.preview, questionData.actual];
-
-    let hasChanged = false;
-    targetTestData.forEach(testData => {
-      if (testData) {
-        testData.code = {};
-        this.updateLastModified(testData);
-        hasChanged = true;
-      }
-    });
-    if (hasChanged) {
-      this.storeData();
-    }
-  }
-
-  clearLastLang(): void {
-    this.autoSavedData.lastLanguageLAT = null;
-    this.updateLastModified(this.autoSavedData);
-    this.storeData();
-  }
-
-  clearSavedTestCases(): void {
-    this.ensureDataStructure();
-    const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
-    const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
-
-    if (targetTestData) {
-      const hasNoCode = !Object.keys(targetTestData.code ?? {}).length;
-
-      if (this.isPreview) {
-        targetTestData.testCasesLAT = [];
-        this.updateLastModified(targetTestData);
-      } else if (hasNoCode) {
-        const allQuestions = this.autoSavedData.assessments[this.assessmentId];
-        delete allQuestions[this.questionId];
-        this.autoSavedData.assessments[this.assessmentId] = { ...allQuestions };
-        this.updateLastModified(this.autoSavedData);
-      }
-      this.storeData();
-    }
-  }
-
-  updateVersion(version: string): void {
-    if (this.autoSavedData.lastLanguageLAT) {
-      this.autoSavedData.lastLanguageLAT.version = version;
-      this.updateLastModified(this.autoSavedData);
-      this.storeData();
-    }
-  }
-
-  updateTestCases(testCases: (ExampleTestCase | CustomTestCase)[]) {
-    if (this.assessmentId && this.questionId && this.testCasesSaveEnabled) {
-      this.ensureDataStructure();
-      const questionData = this.autoSavedData.assessments[this.assessmentId][this.questionId];
-      const targetTestData = this.isPreview ? questionData.preview : questionData.actual;
-
-      if (targetTestData) {
-        targetTestData.testCasesLAT = testCases;
-        this.updateLastModified(targetTestData);
-        this.storeData();
-      }
-    }
-  }
-
-  private storeData(): void {
-    this.storage.store(this.key, this.autoSavedData);
-  }
-
-  private retrieveData(): AutoSavedData | AutoSavedDataV1 {
-    return this.storage.retrieve(this.key) as AutoSavedData | AutoSavedDataV1;
-  }
-
-  /**
-   * Manually triggers data cleanup and migration.
-   * Useful for handling large localStorage or migration when needed.
-   * This can be called from application startup or after major events.
-   */
-  performMaintenanceAndCleanup(): void {
-    // Get current data
-    const savedData = this.storage.retrieve(this.key);
-
-    // If no data, nothing to do
-    if (!savedData) {
-      return;
-    }
-
-    // Check if migration needed
-    if (!('version' in savedData)) {
-      this.migrateFromV1ToV2(savedData as AutoSavedDataV1);
-    } else {
-      // Already migrated, just perform cleanup
-      this.autoSavedData = savedData as AutoSavedData;
-
-      // Perform a more aggressive cleanup for manual maintenance
-      // by temporarily modifying the cleanup thresholds
-      const originalMaxAge = this.MAX_STORAGE_AGE_DAYS;
-      const halfAge = Math.floor(originalMaxAge / 2); // Cut threshold in half
-
-      // Create a custom cleanup function with reduced threshold
-      this.cleanupWithReducedThreshold(halfAge);
-    }
-
-    // Verify localStorage size is manageable
-    try {
-      const serializedData = JSON.stringify(this.autoSavedData);
-      const sizeInKB = Math.round(serializedData.length / 1024);
-
-      // If data is too large (over 2MB), perform more aggressive cleanup
-      if (sizeInKB > 2048) {
-        console.warn(`Local storage data is large (${sizeInKB}KB), performing deep cleanup`);
-
-        // Use extremely aggressive cleanup settings
-        this.cleanupStorageData({
-          storageAgeMultiplier: 0.5, // Even more aggressive - half the normal age
-          minQuestionDataAgeDays: 0.25, // 6 hours minimum
-          assessmentLimitMultiplier: 0.2, // Keep only 20% of assessments
-        });
-
-        // If still too large, keep only a few most recent assessments
-        const newSerializedData = JSON.stringify(this.autoSavedData);
-        const newSizeInKB = Math.round(newSerializedData.length / 1024);
-
-        if (newSizeInKB > 1024) {
-          // Keep only recent assessments
-          const assessments = this.autoSavedData.assessments;
-          // Find the newest timestamp in each assessment
-          const getNewestTimestamp = (obj: Record<string, QuestionData>) =>
-            Object.values(obj).reduce((max, questionData) => Math.max(max, questionData?.lastModified || 0), 0);
-          const entries = Object.entries(assessments).sort(
-            ([, a], [, b]) =>
-              getNewestTimestamp(b as Record<string, QuestionData>) -
-              getNewestTimestamp(a as Record<string, QuestionData>)
-          );
-
-          // Keep only the 5 most recent assessments
-          const keepCount = Math.min(5, entries.length);
-          this.autoSavedData.assessments = {};
-
-          for (let i = 0; i < keepCount; i++) {
-            const [id, data] = entries[i];
-            this.autoSavedData.assessments[id] = data as Record<string, QuestionData>;
-          }
-
-          this.storeData();
-        }
-      }
-    } catch (error) {
-      console.error('Error checking localStorage size', error);
-    }
-  }
-}