gc-alexandria/src/lib/services/publisher.ts

import { get } from 'svelte/store';
import { ndkInstance } from '$lib/ndk';
import { getMimeTags } from '$lib/utils/mime';
import { parseAsciiDocSections, type ZettelSection } from '$lib/utils/ZettelParser';
import { NDKRelaySet, NDKEvent } from '@nostr-dev-kit/ndk';
import { nip19 } from 'nostr-tools';

export interface PublishResult {
  success: boolean;
  eventId?: string;
  error?: string;
}

export interface PublishOptions {
  content: string;
  kind?: number;
  onSuccess?: (eventId: string) => void;
  onError?: (error: string) => void;
}

/**
 * Publishes AsciiDoc content as Nostr events
 * @param options - Publishing options
 * @returns Promise resolving to publish result
 */
export async function publishZettel(options: PublishOptions): Promise<PublishResult> {
  const { content, kind = 30041, onSuccess, onError } = options;
  
  if (!content.trim()) {
    const error = 'Please enter some content';
    onError?.(error);
    return { success: false, error };
  }

  // Get the current NDK instance from the store
  const ndk = get(ndkInstance);
  
  if (!ndk?.activeUser) {
    const error = 'Please log in first';
    onError?.(error);
    return { success: false, error };
  }

  try {
    // Parse content into sections
    const sections = parseAsciiDocSections(content, 2);
    
    if (sections.length === 0) {
      throw new Error('No valid sections found in content');
    }

    // For now, publish only the first section
    const firstSection = sections[0];
    const title = firstSection.title;
    const cleanContent = firstSection.content;
    const sectionTags = firstSection.tags || [];


    // Generate d-tag and create event
    const dTag = generateDTag(title);
    const [mTag, MTag] = getMimeTags(kind);
    
    const tags: string[][] = [
      ['d', dTag],
      mTag,
      MTag,
      ['title', title]
    ];
    if (sectionTags) {
        tags.push(...sectionTags);
    }

    // Create and sign NDK event
    const ndkEvent = new NDKEvent(ndk);
    ndkEvent.kind = kind;
    ndkEvent.created_at = Math.floor(Date.now() / 1000);
    ndkEvent.tags = tags;
    ndkEvent.content = cleanContent;
    ndkEvent.pubkey = ndk.activeUser.pubkey;

    await ndkEvent.sign();

    // Publish to relays
    const allRelayUrls = Array.from(ndk.pool?.relays.values() || []).map(r => r.url);
    
    if (allRelayUrls.length === 0) {
      throw new Error('No relays available in NDK pool');
    }
    
    const relaySet = NDKRelaySet.fromRelayUrls(allRelayUrls, ndk);
    const publishedToRelays = await ndkEvent.publish(relaySet);
    
    if (publishedToRelays.size > 0) {
      const result = { success: true, eventId: ndkEvent.id };
      onSuccess?.(ndkEvent.id);
      return result;
    } else {
      // Try fallback publishing logic here...
      throw new Error('Failed to publish to any relays');
    }
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
    onError?.(errorMessage);
    return { success: false, error: errorMessage };
  }
}

function generateDTag(title: string): string {
  return title
    .toLowerCase()
    .replace(/[^\w\s-]/g, '')
    .replace(/\s+/g, '-');
}