import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as smartfile from '../ts/index.js';
import { MockSmartFs } from './helpers/mock-smartfs.js';

// Create factory with MockSmartFs
const mockFs = new MockSmartFs();
const factory = new smartfile.SmartFileFactory(mockFs);

// ---------------------------
// VirtualDirectory Factory Tests
// ---------------------------

tap.test('SmartFileFactory.virtualDirectoryFromPath() -> should create a VirtualDirectory from fs path', async () => {
  const virtualDir = await factory.virtualDirectoryFromPath('./test/testassets/testfolder');
  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
  expect(virtualDir.smartfileArray.length).toEqual(4);
});

tap.test('SmartFileFactory.virtualDirectoryEmpty() -> should create an empty VirtualDirectory', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
  expect(virtualDir.isEmpty()).toBeTrue();
  expect(virtualDir.size()).toEqual(0);
});

tap.test('SmartFileFactory.virtualDirectoryFromFileArray() -> should create VirtualDirectory from files', async () => {
  const file1 = factory.fromString('file1.txt', 'content1');
  const file2 = factory.fromString('file2.txt', 'content2');

  const virtualDir = factory.virtualDirectoryFromFileArray([file1, file2]);
  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
  expect(virtualDir.size()).toEqual(2);
});

// ---------------------------
// VirtualDirectory Collection Methods
// ---------------------------

tap.test('VirtualDirectory -> should add and list files', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  const file1 = factory.fromString('test1.txt', 'content1');
  const file2 = factory.fromString('test2.txt', 'content2');

  virtualDir.addSmartfile(file1);
  virtualDir.addSmartfile(file2);

  const files = virtualDir.listFiles();
  expect(files.length).toEqual(2);
  expect(files[0].path).toEqual('test1.txt');
  expect(files[1].path).toEqual('test2.txt');
});

tap.test('VirtualDirectory -> should check file existence', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  const file = factory.fromString('exists.txt', 'content');
  virtualDir.addSmartfile(file);

  expect(virtualDir.exists('exists.txt')).toBeTrue();
  expect(virtualDir.has('exists.txt')).toBeTrue();
  expect(virtualDir.exists('not-there.txt')).toBeFalse();
});

tap.test('VirtualDirectory -> should get file by path', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  const file = factory.fromString('getme.txt', 'my content');
  virtualDir.addSmartfile(file);

  const retrieved = await virtualDir.getFileByPath('getme.txt');
  expect(retrieved).not.toBeUndefined();
  expect(retrieved!.parseContentAsString()).toEqual('my content');
});

tap.test('VirtualDirectory -> should remove file by path', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  const file = factory.fromString('remove.txt', 'content');
  virtualDir.addSmartfile(file);

  expect(virtualDir.exists('remove.txt')).toBeTrue();

  const removed = virtualDir.removeByPath('remove.txt');
  expect(removed).toBeTrue();
  expect(virtualDir.exists('remove.txt')).toBeFalse();
});

tap.test('VirtualDirectory -> should clear all files', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
  virtualDir.addSmartfile(factory.fromString('file2.txt', 'content2'));

  expect(virtualDir.size()).toEqual(2);

  virtualDir.clear();

  expect(virtualDir.size()).toEqual(0);
  expect(virtualDir.isEmpty()).toBeTrue();
});

tap.test('VirtualDirectory -> should merge with another VirtualDirectory', async () => {
  const vdir1 = factory.virtualDirectoryEmpty();
  vdir1.addSmartfile(factory.fromString('file1.txt', 'content1'));

  const vdir2 = factory.virtualDirectoryEmpty();
  vdir2.addSmartfile(factory.fromString('file2.txt', 'content2'));

  vdir1.merge(vdir2);

  expect(vdir1.size()).toEqual(2);
  expect(vdir1.exists('file1.txt')).toBeTrue();
  expect(vdir1.exists('file2.txt')).toBeTrue();
});

tap.test('VirtualDirectory -> should filter files', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
  virtualDir.addSmartfile(factory.fromString('file2.md', 'content2'));
  virtualDir.addSmartfile(factory.fromString('file3.txt', 'content3'));

  const filtered = virtualDir.filter(file => file.path.endsWith('.txt'));

  expect(filtered.size()).toEqual(2);
  expect(filtered.exists('file1.txt')).toBeTrue();
  expect(filtered.exists('file3.txt')).toBeTrue();
  expect(filtered.exists('file2.md')).toBeFalse();
});

tap.test('VirtualDirectory -> should map files', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
  virtualDir.addSmartfile(factory.fromString('file2.txt', 'content2'));

  const mapped = virtualDir.map(file => {
    file.setContentsFromString(file.parseContentAsString().toUpperCase());
    return file;
  });

  const files = mapped.listFiles();
  expect(files[0].parseContentAsString()).toEqual('CONTENT1');
  expect(files[1].parseContentAsString()).toEqual('CONTENT2');
});

tap.test('VirtualDirectory -> should find files', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('find.txt', 'findme'));
  virtualDir.addSmartfile(factory.fromString('other.txt', 'other'));

  const found = virtualDir.find(file => file.parseContentAsString() === 'findme');

  expect(found).not.toBeUndefined();
  expect(found!.path).toEqual('find.txt');
});

tap.test('VirtualDirectory -> should list directories', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('dir1/file1.txt', 'content1'));
  virtualDir.addSmartfile(factory.fromString('dir1/file2.txt', 'content2'));
  virtualDir.addSmartfile(factory.fromString('dir2/file3.txt', 'content3'));
  virtualDir.addSmartfile(factory.fromString('root.txt', 'content4'));

  const dirs = virtualDir.listDirectories();

  expect(dirs).toContain('dir1');
  expect(dirs).toContain('dir2');
  expect(dirs.length).toEqual(2);
});

tap.test('VirtualDirectory -> should save to disk', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('saved1.txt', 'saved content 1'));
  virtualDir.addSmartfile(factory.fromString('subdir/saved2.txt', 'saved content 2'));

  await virtualDir.saveToDisk('./test/testassets/temp/vdir-output');

  // Verify files were written
  const file1 = await factory.fromFilePath('./test/testassets/temp/vdir-output/saved1.txt');
  expect(file1.parseContentAsString()).toEqual('saved content 1');

  const file2 = await factory.fromFilePath('./test/testassets/temp/vdir-output/subdir/saved2.txt');
  expect(file2.parseContentAsString()).toEqual('saved content 2');
});

tap.test('VirtualDirectory -> should convert to transferable object', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('trans1.txt', 'transferable1'));
  virtualDir.addSmartfile(factory.fromString('trans2.txt', 'transferable2'));

  const transferable = await virtualDir.toVirtualDirTransferableObject();

  expect(transferable.files).toBeInstanceOf(Array);
  expect(transferable.files.length).toEqual(2);
});

// TODO: Fix serialization/deserialization with smartjson
// tap.test('VirtualDirectory -> should create from transferable object', async () => {
//   const originalDir = factory.virtualDirectoryEmpty();
//   originalDir.addSmartfile(factory.fromString('original.txt', 'original content'));

//   const transferable = await originalDir.toVirtualDirTransferableObject();
//   const restoredDir = await factory.virtualDirectoryFromTransferable(transferable);

//   expect(restoredDir.size()).toEqual(1);
//   expect(restoredDir.exists('original.txt')).toBeTrue();

//   const file = await restoredDir.getFileByPath('original.txt');
//   expect(file!.parseContentAsString()).toEqual('original content');
// });

tap.test('VirtualDirectory -> should shift to subdirectory', async () => {
  const virtualDir = factory.virtualDirectoryEmpty();
  virtualDir.addSmartfile(factory.fromString('root/sub/file1.txt', 'content1'));
  virtualDir.addSmartfile(factory.fromString('root/sub/file2.txt', 'content2'));
  virtualDir.addSmartfile(factory.fromString('root/other.txt', 'content3'));

  const shifted = await virtualDir.shiftToSubdirectory('root/sub');

  expect(shifted.size()).toEqual(2);
  expect(shifted.exists('file1.txt')).toBeTrue();
  expect(shifted.exists('file2.txt')).toBeTrue();
  expect(shifted.exists('other.txt')).toBeFalse();
});

tap.test('VirtualDirectory -> should add another virtual directory with new root', async () => {
  const vdir1 = factory.virtualDirectoryEmpty();
  vdir1.addSmartfile(factory.fromString('existing.txt', 'existing'));

  const vdir2 = factory.virtualDirectoryEmpty();
  vdir2.addSmartfile(factory.fromString('added.txt', 'added'));

  await vdir1.addVirtualDirectory(vdir2, 'newroot');

  expect(vdir1.size()).toEqual(2);
  expect(vdir1.exists('existing.txt')).toBeTrue();
  expect(vdir1.exists('newroot/added.txt')).toBeTrue();
});

tap.start();