import { FoamGraph } from '../model/graph';
import { URI } from '../model/uri';
import {
  createNoteFromMarkdown,
  createTestWorkspace,
  InMemoryDataStore,
} from '../../test/test-utils';
import { testExportTarget } from '../../test/test-export-target';
import { buildSite } from './index';
import { selectWhere } from './selectors';

describe('export buildSite metadata and homepage selection', () => {
  it('supports programmable site metadata, homepage selection, and filtering', async () => {
    const root = URI.file('/');
    const dataStore = new InMemoryDataStore();
    const workspace = createTestWorkspace([root], dataStore);

    const homeUri = root.joinPath('welcome.md');
    const hiddenUri = root.joinPath('draft.md');
    const guideUri = root.joinPath('guide.md');

    const homeContent = [
      '---',
      'title: Welcome',
      'description: Start here',
      'home: true',
      'draft: false',
      '---',
      '',
      '# Welcome',
    ].join('\n');
    const hiddenContent = [
      '---',
      'title: Draft',
      'draft: true',
      '---',
      '',
      '# Draft',
    ].join('\n');
    const guideContent = ['# Guide'].join('\n');

    dataStore.set(homeUri, homeContent);
    dataStore.set(hiddenUri, hiddenContent);
    dataStore.set(guideUri, guideContent);

    workspace
      .set(createNoteFromMarkdown('welcome.md', homeContent, root))
      .set(createNoteFromMarkdown('draft.md', hiddenContent, root))
      .set(createNoteFromMarkdown('guide.md', guideContent, root));

    const graph = FoamGraph.fromWorkspace(workspace);
    const result = await buildSite(
      {
        workspace,
        graph,
        select: selectWhere(resource => resource.properties.draft !== true),
        site: {
          title: ({ notes }) => `Exported Notes (${notes.length})`,
          description: 'A programmable export surface',
          homepage: note => note.properties.home === true,
        },
      },
      testExportTarget()
    );

    expect(result.site).toEqual({
      title: 'Exported Notes (2)',
      description: 'A programmable export surface',
      homepageRoute: '/welcome',
    });
    expect(result.diagnostics).toEqual([]);
    expect(result.routes).toEqual(
      expect.arrayContaining([
        { sourceUri: homeUri, route: '/welcome' },
        { sourceUri: guideUri, route: '/guide' },
      ])
    );
    expect(
      result.routes.find(route => route.sourceUri.path === hiddenUri.path)
    ).toBeUndefined();

    const exportedHome = result.notes.find(note => note.route === '/welcome');
    expect(exportedHome).toMatchObject({
      title: 'Welcome',
      description: 'Start here',
      properties: {
        title: 'Welcome',
        description: 'Start here',
        home: true,
        draft: false,
      },
    });
    expect(result.notes.find(note => note.route === '/guide')?.properties).toEqual(
      {}
    );
    expect(result.notes.find(note => note.route === '/draft')).toBeUndefined();
  });

  it('resolves homepage source paths relative to the workspace', async () => {
    const root = URI.file('/');
    const dataStore = new InMemoryDataStore();
    const workspace = createTestWorkspace([root], dataStore);

    const homeUri = root.joinPath('user', 'index.md');
    const guideUri = root.joinPath('user', 'guide.md');
    const homeContent = '# Home';
    const guideContent = '# Guide';

    dataStore.set(homeUri, homeContent);
    dataStore.set(guideUri, guideContent);

    workspace
      .set(createNoteFromMarkdown('user/index.md', homeContent, root))
      .set(createNoteFromMarkdown('user/guide.md', guideContent, root));

    const result = await buildSite(
      {
        workspace,
        graph: FoamGraph.fromWorkspace(workspace),
        contentRoot: 'user',
        site: {
          homepage: 'user/guide.md',
        },
      },
      testExportTarget()
    );

    expect(result.site).toEqual({
      title: undefined,
      description: undefined,
      homepageRoute: '/guide',
    });
  });
});