/**
 * MSD Tools Tests - dedicated temp subdirectory
 *
 * Tests for issue #1975: MSD temp files should use a dedicated
 * subdirectory (path.join(os.tmpdir(), 'msd')) instead of writing
 * directly to os.tmpdir().
 */

const { test, describe, beforeEach } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('fs');
const path = require('path');
const os = require('os');

const {
  reapStaleTempFiles,
} = require('../msd-core/bin/lib/io.cjs');

const MSD_TEMP_DIR = path.join(os.tmpdir(), 'msd');

// ─── Dedicated temp subdirectory ────────────────────────────────────────────

describe('dedicated msd temp subdirectory', () => {
  describe('output() temp file placement', () => {
    // output() writes to tmpfile when JSON > 50KB. We test indirectly by
    // checking that reapStaleTempFiles scans the subdirectory.

    test('msd temp subdirectory path is os.tmpdir()/msd', () => {
      // The MSD_TEMP_DIR constant should resolve to <tmpdir>/msd
      assert.strictEqual(MSD_TEMP_DIR, path.join(os.tmpdir(), 'msd'));
    });
  });

  describe('reapStaleTempFiles with subdirectory', () => {
    let testPrefix;

    beforeEach(() => {
      testPrefix = `msd-tempsub-test-${Date.now()}-`;
      // Ensure the msd subdirectory exists for test setup
      fs.mkdirSync(MSD_TEMP_DIR, { recursive: true });
    });

    test('removes stale files from msd subdirectory', () => {
      const stalePath = path.join(MSD_TEMP_DIR, `${testPrefix}stale.json`);
      fs.writeFileSync(stalePath, '{}');
      const oldTime = new Date(Date.now() - 10 * 60 * 1000);
      fs.utimesSync(stalePath, oldTime, oldTime);

      reapStaleTempFiles(testPrefix, { maxAgeMs: 5 * 60 * 1000 });

      assert.ok(!fs.existsSync(stalePath), 'stale file in msd subdir should be removed');
    });

    test('preserves fresh files in msd subdirectory', () => {
      const freshPath = path.join(MSD_TEMP_DIR, `${testPrefix}fresh.json`);
      fs.writeFileSync(freshPath, '{}');

      reapStaleTempFiles(testPrefix, { maxAgeMs: 5 * 60 * 1000 });

      assert.ok(fs.existsSync(freshPath), 'fresh file in msd subdir should be preserved');
      // Clean up
      fs.unlinkSync(freshPath);
    });

    test('removes stale directories from msd subdirectory', () => {
      const staleDir = path.join(MSD_TEMP_DIR, `${testPrefix}dir`);
      fs.mkdirSync(staleDir, { recursive: true });
      const oldTime = new Date(Date.now() - 10 * 60 * 1000);
      fs.utimesSync(staleDir, oldTime, oldTime);

      reapStaleTempFiles(testPrefix, { maxAgeMs: 5 * 60 * 1000 });

      assert.ok(!fs.existsSync(staleDir), 'stale directory in msd subdir should be removed');
    });

    test('creates msd subdirectory if it does not exist', () => {
      // Use a unique nested path to avoid interfering with other tests
      const uniqueSubdir = path.join(os.tmpdir(), `msd-creation-test-${Date.now()}`);

      // Verify it does not exist
      if (fs.existsSync(uniqueSubdir)) {
        // eslint-disable-next-line local/no-raw-rmsync-in-tests -- mid-test pre-condition reset: ensures uniqueSubdir is absent before testing SUT creation behavior
        fs.rmSync(uniqueSubdir, { recursive: true, force: true });
      }
      assert.ok(!fs.existsSync(uniqueSubdir), 'test subdir should not exist before test');

      // reapStaleTempFiles should not throw even if subdir does not exist
      // (it gets created or handled gracefully)
      assert.doesNotThrow(() => {
        reapStaleTempFiles(`msd-creation-test-${Date.now()}-`, { maxAgeMs: 0 });
      });
    });

    test('does not scan system tmpdir root for msd- files', () => {
      // Place a stale file in the OLD location (system tmpdir root)
      const oldLocationPath = path.join(os.tmpdir(), `${testPrefix}old-location.json`);
      fs.writeFileSync(oldLocationPath, '{}');
      const oldTime = new Date(Date.now() - 10 * 60 * 1000);
      fs.utimesSync(oldLocationPath, oldTime, oldTime);

      // reapStaleTempFiles should NOT remove files from the old location
      // because it now only scans the msd subdirectory
      reapStaleTempFiles(testPrefix, { maxAgeMs: 5 * 60 * 1000 });

      // The file in the old location should still exist (not scanned)
      assert.ok(
        fs.existsSync(oldLocationPath),
        'files in system tmpdir root should NOT be scanned by reapStaleTempFiles'
      );

      // Clean up manually
      fs.unlinkSync(oldLocationPath);
    });

    test('backward compat: reapStaleTempFilesLegacy cleans old location', () => {
      // Place a stale file in the old location (system tmpdir root)
      const oldLocationPath = path.join(os.tmpdir(), `${testPrefix}legacy.json`);
      fs.writeFileSync(oldLocationPath, '{}');
      const oldTime = new Date(Date.now() - 10 * 60 * 1000);
      fs.utimesSync(oldLocationPath, oldTime, oldTime);

      // The legacy reap function should still clean old-location files
      // We import it if exported, or verify the main reap handles both
      const ioModule = require('../msd-core/bin/lib/io.cjs');
      if (typeof ioModule.reapStaleTempFilesLegacy === 'function') {
        ioModule.reapStaleTempFilesLegacy(testPrefix, { maxAgeMs: 5 * 60 * 1000 });
        assert.ok(!fs.existsSync(oldLocationPath), 'legacy reap should clean old location');
      } else {
        // If no separate legacy function, the main output() should do a one-time
        // migration sweep. We just verify the export shape is correct.
        assert.ok(typeof ioModule.reapStaleTempFiles === 'function');
        // Clean up manually since we're not testing migration here
        fs.unlinkSync(oldLocationPath);
      }
    });
  });
});