const sourcesCollection = defineCollection({
  loader: glob({
    pattern: "**/*.md",
    base: resolveContentPath("sources"),
    generateId: ({ entry }) => {
      // Preserve directory structure in ID for nested folder routing
      return entry.replace(/\.md$/, '').toLowerCase();
    }
  }),
  schema: z.object({
    // Ultra-permissive schema - everything optional
    title: z.string().optional(),
    url: z.string().optional(),
    date_created: z.union([z.string(), z.date()]).optional(),
    date_modified: z.union([z.string(), z.date()]).optional(),
    tags: z.union([z.string(), z.array(z.string())]).optional(),
    publish: z.boolean().optional(),
  }).passthrough() // Allow any additional frontmatter
});

// In paths export
'sources': resolveContentPath('sources'),

// In collections export
'sources': sourcesCollection,

---
import { getCollection } from 'astro:content';
import Layout from '@layouts/Layout.astro';
import OneArticle from '@layouts/OneArticle.astro';
import OneArticleOnPage from '@components/articles/OneArticleOnPage.astro';
import { getReferenceSlug, toProperCase } from '@utils/slugify';

export const prerender = true;

export async function getStaticPaths() {
  const sourcesEntries = await getCollection('sources');
  const paths = [];
  const errors = [];

  for (const entry of sourcesEntries) {
    try {
      // Generate slug from entry ID (preserves folder structure)
      const slug = getReferenceSlug(entry.id);

      // Derive title from filename if not in frontmatter
      const filename = entry.id.split('/').pop()?.replace(/\.md$/, '') || entry.id;
      const title = entry.data.title || toProperCase(filename);

      paths.push({
        params: { slug },
        props: {
          entry: {
            ...entry,
            data: {
              ...entry.data,
              title, // Ensure title is always present
            }
          },
          folder: entry.id.includes('/') ? entry.id.split('/')[0] : 'root'
        }
      });
    } catch (error) {
      // Log error but don't fail the build
      console.warn(`[SOURCES] Skipping ${entry.id}: ${error.message}`);
      errors.push({ id: entry.id, error: error.message });
    }
  }

  if (errors.length > 0) {
    console.warn(`[SOURCES] ${errors.length} entries skipped due to errors`);
  }

  return paths;
}

interface Props {
  entry: any;
  folder: string;
}

const { entry, folder } = Astro.props;

// Build content data for components
const contentData = {
  path: Astro.url.pathname,
  id: entry.id,
  title: entry.data.title,
  contentType: 'sources',
  folder
};
---

<Layout
  title={entry.data.title}
  frontmatter={entry.data}
>
  <OneArticle
    Component={OneArticleOnPage}
    title={entry.data.title}
    content={entry.body || ''}
    markdownFile={entry.id}
    data={contentData}
  />
</Layout>

---
import Layout from '@layouts/Layout.astro';
import { getCollection } from 'astro:content';
import { toProperCase, getReferenceSlug } from '@utils/slugify';

const sourcesEntries = await getCollection('sources');

// Group entries by top-level folder
const entriesByFolder = new Map<string, typeof sourcesEntries>();
entriesByFolder.set('root', []); // Files not in a subfolder

for (const entry of sourcesEntries) {
  const parts = entry.id.split('/');
  const folder = parts.length > 1 ? parts[0] : 'root';

  if (!entriesByFolder.has(folder)) {
    entriesByFolder.set(folder, []);
  }
  entriesByFolder.get(folder)!.push(entry);
}

// Sort folders alphabetically, but keep 'root' first or last as preferred
const folders = Array.from(entriesByFolder.keys()).sort((a, b) => {
  if (a === 'root') return 1; // Put root at end
  if (b === 'root') return -1;
  return a.localeCompare(b);
});

// Process entries to ensure they have titles
const processedEntries = sourcesEntries.map(entry => {
  const filename = entry.id.split('/').pop()?.replace(/\.md$/, '') || entry.id;
  return {
    ...entry,
    slug: getReferenceSlug(entry.id),
    displayTitle: entry.data.title || toProperCase(filename),
    folder: entry.id.includes('/') ? entry.id.split('/')[0] : 'root'
  };
}).sort((a, b) => a.displayTitle.localeCompare(b.displayTitle));
---

<Layout title="Sources" description="Browse our collection of sources and references">
  <div class="sources-container">
    <h1>Sources</h1>
    <p class="description">A collection of references, people, books, and other sources we've gathered.</p>

    <!-- Tab Navigation -->
    <div class="tab-nav">
      <button class="tab-btn active" data-folder="all">
        All <span class="count">{sourcesEntries.length}</span>
      </button>
      {folders.map(folder => (
        <button class="tab-btn" data-folder={folder}>
          {folder === 'root' ? 'Uncategorized' : toProperCase(folder)}
          <span class="count">{entriesByFolder.get(folder)?.length || 0}</span>
        </button>
      ))}
    </div>

    <!-- Content Grid -->
    <div class="sources-grid">
      {processedEntries.map(entry => (
        <div class="source-card" data-folder={entry.folder}>
          <a href={`/sources/${entry.slug}`} class="source-link">
            <span class="source-title">{entry.displayTitle}</span>
            {entry.folder !== 'root' && (
              <span class="source-folder">{toProperCase(entry.folder)}</span>
            )}
          </a>
        </div>
      ))}
    </div>
  </div>
</Layout>

<script>
  // Client-side tab filtering
  document.addEventListener('DOMContentLoaded', () => {
    const tabs = document.querySelectorAll('.tab-btn');
    const cards = document.querySelectorAll('.source-card');

    tabs.forEach(tab => {
      tab.addEventListener('click', () => {
        const folder = tab.getAttribute('data-folder');

        // Update active tab
        tabs.forEach(t => t.classList.remove('active'));
        tab.classList.add('active');

        // Filter cards
        cards.forEach(card => {
          const cardFolder = card.getAttribute('data-folder');
          if (folder === 'all' || cardFolder === folder) {
            card.style.display = '';
          } else {
            card.style.display = 'none';
          }
        });
      });
    });
  });
</script>

<style>
  /* Styles following existing patterns from ReferenceLayout */
</style>

const defaultRouteMappings: RouteMapping[] = [
  // ... existing mappings ...
  {
    contentPath: 'sources',
    routePath: 'sources'
  },
  // ... other mappings ...
];

export const ROUTE_PATHS = {
  // ... existing paths ...

  SOURCES: {
    BASE: '/sources',
  },

  // ... other paths ...
} as const;

const PRIORITY_CONTENT_PATHS = [
  'tooling/Portfolio',
  'tooling',
  'vocabulary',
  'concepts',
  'sources',  // Add this for bare source name resolution
];

// In getStaticPaths() and index page
const getDisplayTitle = (entry: any): string => {
  // Priority: title → og_title → filename
  if (entry.data.title && entry.data.title.trim()) {
    return entry.data.title;
  }
  if (entry.data.og_title && entry.data.og_title.trim()) {
    return entry.data.og_title;
  }
  // Fallback to filename with proper casing
  const filename = entry.id.split('/').pop()?.replace(/\.md$/, '') || entry.id;
  return toProperCase(filename);
};

// Wrap each entry in try/catch
try {
  // Process entry
} catch (error) {
  console.warn(`[SOURCES] Skipping ${entry.id}: ${error.message}`);
  // Continue with other entries
}

// Defensive content handling
const body = entry.body || '';
const title = entry.data?.title || toProperCase(filename);