post-repository.ts

import fs from 'fs';
import path from 'path';
import type { FeedData, Feed, FeedFrontmatter } from '@/blog/model/types';
import { FeedFrontmatterSchema } from '@/blog/model/frontmatter-schema';
import {
  filterListedPosts,
  isListedPost,
  type PublicationQueryOptions,
} from './policy';

const postsDirectory = path.join(process.cwd(), 'posts');
const isProduction = process.env.NODE_ENV === 'production';
const shouldLogContentIssues = process.env.NODE_ENV !== 'test';

// Cache for folder path lookups by slug
const slugToFolderCache = new Map<string, string>();
let cachedSortedFeedData: FeedData[] | null = null;

function normalizeSlug(slug: string): string {
  try {
    return decodeURIComponent(slug);
  } catch {
    return slug;
  }
}

function logContentIssue(message: string): void {
  if (!shouldLogContentIssues) {
    return;
  }

  console.warn(`[post-repository] ${message}`);
}
export type FeedQueryOptions = PublicationQueryOptions;

// TOC item type
export interface TocItem {
  id: string;
  text: string;
  level: number;
  children?: TocItem[];
}

// Safe file system utilities
function safeReadFile(filePath: string): string | null {
  try {
    return fs.readFileSync(filePath, 'utf8');
  } catch {
    logContentIssue('Failed to read a content file.');
    return null;
  }
}

function safeReaddir(dirPath: string): string[] | null {
  try {
    return fs.readdirSync(dirPath);
  } catch {
    logContentIssue('Failed to read a content directory.');
    return null;
  }
}

function safeExists(p: string): boolean {
  try {
    return fs.existsSync(p);
  } catch {
    logContentIssue('Failed to check content path existence.');
    return false;
  }
}

function isDirectory(p: string): boolean {
  try {
    return fs.statSync(p).isDirectory();
  } catch {
    return false;
  }
}

// Recursively find all post folders (folders with index.mdx + meta.json)
function findAllPostFolders(dir: string, relativePath: string = ''): string[] {
  const folders: string[] = [];
  const items = safeReaddir(dir);

  if (!items) return folders;

  for (const item of items) {
    const fullPath = path.join(dir, item);
    if (!isDirectory(fullPath)) continue;

    const currentRelPath = relativePath ? `${relativePath}/${item}` : item;
    const hasIndex = safeExists(path.join(fullPath, 'index.mdx'));
    const hasMeta = safeExists(path.join(fullPath, 'meta.json'));

    if (hasIndex && hasMeta) {
      folders.push(currentRelPath);
    }

    // Recursively search subdirectories (for series folders)
    const subFolders = findAllPostFolders(fullPath, currentRelPath);
    folders.push(...subFolders);
  }

  return folders;
}

// Validate frontmatter
function validateFeedFrontmatter(
  data: unknown,
  folderPath: string
): FeedFrontmatter | null {
  const result = FeedFrontmatterSchema.safeParse(data);

  if (!result.success) {
    logContentIssue(`Invalid frontmatter for ${folderPath}.`);
    return null;
  }

  return result.data;
}

const PROSE_CHARACTERS_PER_MINUTE = 700;
const TABLE_READING_WEIGHT = 0.35;
const FENCED_CODE_BLOCK_REGEX = /```[\s\S]*?```/g;
const DETAILS_BLOCK_REGEX = /<details[\s\S]*?<\/details>/gi;
const IMAGE_LINK_REGEX = /!\[.*?\]\(.*?\)/g;
const MARKDOWN_LINK_REGEX = /\[(.*?)\]\(.*?\)/g;
const HTML_TAG_REGEX = /<\/?[^>]+>/g;
const MARKDOWN_DECORATION_REGEX = /[#*_`]/g;
const LEADING_MARKER_REGEX = /^\s*[>\-+]\s?/gm;
const TABLE_DELIMITER_REGEX = /^\|?[\s:-|]+\|?$/;

function normalizeReadableLine(line: string): string {
  return line
    .replace(HTML_TAG_REGEX, ' ')
    .replace(MARKDOWN_DECORATION_REGEX, ' ')
    .replace(LEADING_MARKER_REGEX, '')
    .replace(/\s+/g, ' ')
    .trim();
}

function weightedReadingLength(content: string): number {
  const withoutHiddenContent = content
    .replace(DETAILS_BLOCK_REGEX, ' ')
    .replace(FENCED_CODE_BLOCK_REGEX, ' ')
    .replace(IMAGE_LINK_REGEX, ' ')
    .replace(MARKDOWN_LINK_REGEX, '$1');

  const lines = withoutHiddenContent.split('\n');
  let proseLength = 0;
  let tableLength = 0;

  for (const rawLine of lines) {
    const line = rawLine.trim();

    if (!line) {
      continue;
    }

    if (line.startsWith('|')) {
      if (TABLE_DELIMITER_REGEX.test(line)) {
        continue;
      }

      const normalizedTableLine = normalizeReadableLine(
        line.replace(/\|/g, ' ')
      );
      tableLength += normalizedTableLine.length;
      continue;
    }

    proseLength += normalizeReadableLine(line).length;
  }

  return proseLength + Math.ceil(tableLength * TABLE_READING_WEIGHT);
}

// Calculate reading time from MDX content
export function calculateReadingTime(content: string): number {
  const length = weightedReadingLength(content);
  return Math.max(1, Math.ceil(length / PROSE_CHARACTERS_PER_MINUTE));
}

const CONTENT_IMAGE_SOURCE_REGEX =
  /!\[[^\]]*]\(([^)\s]+(?:\s+"[^"]*")?)\)|<(?:img|Image)\b[^>]*?\bsrc=["']([^"']+)["'][^>]*?>/g;

function normalizeImageSource(source: string): string {
  const trimmedSource = source.trim();

  if (
    trimmedSource.startsWith('<') &&
    trimmedSource.endsWith('>') &&
    trimmedSource.length > 2
  ) {
    return trimmedSource.slice(1, -1);
  }

  const [urlToken] = trimmedSource.split(/\s+/);
  return urlToken;
}

function extractFirstImageSource(content: string): string | undefined {
  const matches = content.matchAll(CONTENT_IMAGE_SOURCE_REGEX);

  for (const match of matches) {
    const candidateSource = match[1] ?? match[2];

    if (candidateSource) {
      return normalizeImageSource(candidateSource);
    }
  }

  return undefined;
}

// Load metadata from JSON file (folder path relative to posts/)
function loadMetadata(folderPath: string): FeedFrontmatter | null {
  const metaPath = path.join(postsDirectory, folderPath, 'meta.json');
  const metaContents = safeReadFile(metaPath);

  if (!metaContents) {
    logContentIssue(`Metadata file missing for ${folderPath}.`);
    return null;
  }

  try {
    const data = JSON.parse(metaContents);
    const metadata = validateFeedFrontmatter(data, folderPath);

    if (!metadata) {
      return null;
    }

    const needsMdxRead = !metadata.readingTime || !metadata.image;

    if (needsMdxRead) {
      const mdxPath = path.join(postsDirectory, folderPath, 'index.mdx');
      const mdxContents = safeReadFile(mdxPath);

      if (mdxContents) {
        if (!metadata.readingTime) {
          metadata.readingTime = calculateReadingTime(mdxContents);
        }

        if (!metadata.image) {
          metadata.image = extractFirstImageSource(mdxContents);
        }
      }
    }

    // Cache the slug -> folder path mapping
    slugToFolderCache.set(metadata.slug, folderPath);

    return metadata;
  } catch {
    logContentIssue(`Failed to parse metadata for ${folderPath}.`);
    return null;
  }
}

// Get folder path from slug (using cache or scanning)
export function getFolderSlug(slug: string): string | null {
  const normalizedSlug = normalizeSlug(slug);

  // Check cache first
  if (slugToFolderCache.has(normalizedSlug)) {
    return slugToFolderCache.get(normalizedSlug)!;
  }

  // Populate slug cache by loading full feed index first
  getSortedFeedData({ includePrivate: true });
  if (slugToFolderCache.has(normalizedSlug)) {
    return slugToFolderCache.get(normalizedSlug)!;
  }

  if (isProduction) {
    return null;
  }

  // If not cached, scan all folders to build cache
  const allFolders = findAllPostFolders(postsDirectory);

  for (const folderPath of allFolders) {
    const metadata = loadMetadata(folderPath);
    if (metadata?.slug === normalizedSlug) {
      return folderPath;
    }
  }

  return null;
}

// Get all feed slugs for static generation
export function getAllFeedSlugs(options: FeedQueryOptions = {}) {
  return getSortedFeedData(options).map((feed) => ({ slug: feed.slug }));
}

// Get sorted feed data for listing pages
export function getSortedFeedData(options: FeedQueryOptions = {}): FeedData[] {
  if (isProduction && cachedSortedFeedData) {
    return filterListedPosts(cachedSortedFeedData, options);
  }

  if (!safeExists(postsDirectory)) {
    logContentIssue('Posts directory does not exist.');
    return [];
  }

  const allFolders = findAllPostFolders(postsDirectory);

  const allFeedData = allFolders
    .map((folderPath) => {
      const metadata = loadMetadata(folderPath);

      if (!metadata) {
        logContentIssue(`Failed to load metadata for ${folderPath}.`);
        return null;
      }

      return metadata as FeedData; // slug is already included in FeedFrontmatter
    })
    .filter((feed): feed is FeedData => feed !== null);

  // Sort by date (newest first)
  const sortedFeedData = allFeedData.sort((a, b) => {
    if (a.date < b.date) {
      return 1;
    } else {
      return -1;
    }
  });

  if (isProduction) {
    cachedSortedFeedData = sortedFeedData;
  }

  return filterListedPosts(sortedFeedData, options);
}

// Get single feed data with MDX component
export async function getFeedData(
  slug: string,
  options: FeedQueryOptions = {}
): Promise<Feed | null> {
  const folderPath = getFolderSlug(slug);

  if (!folderPath) {
    logContentIssue(`Could not find folder for slug ${slug}.`);
    return null;
  }

  const metadata = loadMetadata(folderPath);

  if (!metadata) {
    logContentIssue(`Failed to load metadata for ${folderPath}.`);
    return null;
  }

  if (!isListedPost(metadata, options)) {
    return null;
  }

  try {
    // Dynamic import of MDX file using folder path
    const mdxModule = await import(`@/../posts/${folderPath}/index.mdx`);

    return {
      ...metadata,
      Content: mdxModule.default,
    } as Feed;
  } catch {
    logContentIssue(`Failed to load MDX content for ${folderPath}.`);
    return null;
  }
}