main.ts

import {
	App,
	Modal,
	Notice,
	Plugin,
	PluginSettingTab,
	Setting,
	TFile,
	requestUrl
} from "obsidian";

interface TranscriptItem {
	text: string;
	duration: number;
	offset: number;
}

interface PluginSettings {
	noteFolder: string;
}

const DEFAULT_SETTINGS: PluginSettings = {
	noteFolder: "",
};

interface VideoMetadata {
	title: string;
	channel: string;
	duration: string;
	publishDate: string;
}

const RE_YOUTUBE = /(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/i;
const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36';
const RE_XML_TRANSCRIPT = /<text start="([^"]*)" dur="([^"]*)">([^<]*)<\/text>/g;

interface YouTubeResponse {
	status: string;
	data: {
		title: string;
		description: string;
		date: string;
		url: string;
		duration: string;
		channel: string;
		thumbnail_url: string;
		transcript: string;
		video_id: string;
	};
}

export default class YouTubeTranscriptPlugin extends Plugin {
	settings: PluginSettings = DEFAULT_SETTINGS;
	private readonly DEBUG = true;

	async onload() {
		console.log("Loading YouTubeTranscriptPlugin");
		this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());

		this.addCommand({
			id: "open-yt-transcript-modal",
			name: "Fetch YouTube Transcript",
			callback: () => {
				new YouTubeTranscriptModal(this.app, this).open();
			},
		});

		this.addSettingTab(new YouTubeTranscriptPluginSettingTab(this.app, this));
	}

	async fetchTranscript(url: string): Promise<string> {
		this.debug("Fetching transcript for URL:", url);

		try {
			const cleanUrl = this.cleanYouTubeUrl(url);
			this.debug("Cleaned URL:", cleanUrl);

			const requestBody = {
				url: cleanUrl
			};
			this.debug("Request body:", requestBody);

			const response = await requestUrl({
				url: 'https://yt-transcripts.replit.app/api/convert/json',
				method: 'POST',
					headers: {
						'Content-Type': 'application/json',
						'Accept': 'application/json'
					},
					body: JSON.stringify(requestBody)
			});

			this.debug("API Response status:", response.status);
			this.debug("API Response text:", response.text);

			if (response.status !== 200) {
				let errorMessage = "Failed to fetch transcript";
				try {
					const errorData = response.json;
					this.debug("Error response data:", errorData);
					errorMessage = errorData?.detail || errorMessage;
				} catch (e) {
					errorMessage = response.text || errorMessage;
				}
				throw new Error(errorMessage);
			}

			let data: YouTubeResponse;
			try {
				data = typeof response.json === 'string' ? 
					JSON.parse(response.json) : 
					response.json as YouTubeResponse;
			} catch (e) {
				this.debug("Error parsing JSON response:", e);
				throw new Error("Invalid JSON response from service");
			}

			if (data.status !== "success" || !data.data) {
				this.debug("Invalid API response:", data);
				throw new Error("Invalid response from transcript service");
			}

			return this.formatTranscriptNote(data.data);
		} catch (error) {
			this.debug("Error fetching transcript:", error);
			const errorMessage = error instanceof Error ? error.message : "Unknown error";
			throw new Error(`Failed to fetch transcript: ${errorMessage}`);
		}
	}

	private retrieveVideoId(videoId: string): string {
		if (videoId.length === 11) {
			return videoId;
		}
		const matchId = videoId.match(RE_YOUTUBE);
		if (matchId && matchId.length) {
			return matchId[1];
		}
		throw new Error('Invalid YouTube URL or video ID');
	}

	public getFormattedDateTime(): string {
		const now = new Date();
		const date = now.toISOString().split('T')[0];
		const time = now.toTimeString()
			.split(' ')[0]
			.replace(/:/g, '-');
		return `${date}-${time}`;
	}

	private sanitizeTitle(title: string): string {
		return title
			.replace(/[/\\?%*:|"<>]/g, '-')
			.replace(/\s+/g, '-')
			.replace(/-+/g, '-')
			.toLowerCase();
	}

	private formatDate(date: Date): string {
		return date.toISOString().split('T')[0];
	}

	private decodeHtmlEntities(text: string): string {
		const entities: Record<string, string> = {
			'&amp;': '&',
			'&lt;': '<',
			'&gt;': '>',
			'&quot;': '"',
			'&#39;': "'",
			'&apos;': "'",
		};
		
		return text.replace(/&amp;#39;|&amp;|&lt;|&gt;|&quot;|&#39;|&apos;/g, 
			(entity: string): string => entities[entity] || entity
		);
	}

	private async formatTranscriptNote(data: YouTubeResponse['data']): Promise<string> {
		try {
			const transcriptText = this.decodeHtmlEntities(data.transcript);
			const duration = parseInt(data.duration);
			const formattedDuration = duration ? 
				`${Math.floor(duration / 60)}:${(duration % 60).toString().padStart(2, '0')}` : 
				"Unknown Duration";

			const templateContent = `---
title: ${data.title}
description: ${data.description.split('\n')[0]}
created: ${this.getFormattedDateTime()}
video-id: ${data.video_id}
url: ${data.url}
duration: ${formattedDuration}
channel: ${data.channel}
date: ${data.date}
thumbnail: ${data.thumbnail_url}
tags:
  - youtube-transcript
  - video
---

# ${data.title}

## Video Information
- **Channel**: ${data.channel}
- **Published**: ${data.date}
- **Duration**: ${formattedDuration}
- **URL**: [Watch Video](${data.url})
- **Thumbnail**: ![Thumbnail](${data.thumbnail_url})

## Description
${data.description}

## Transcript

${transcriptText}

## Key Points
- 

## Notes
- 

## Related
- 
`;

			return templateContent;
		} catch (error) {
			console.error("Error creating note from template:", error);
			return this.createFallbackNote(data);
		}
	}

	private createFallbackNote(data: YouTubeResponse['data']): string {
		return `---
title: ${data.title || "YouTube Transcript"}
description: ${data.description?.split('\n')[0] || "Transcript of YouTube video"}
date: ${data.date || this.formatDate(new Date())}
url: ${data.url}
tags:
  - youtube-transcript
  - video
---

# ${data.title || "YouTube Video Transcript"}

## Video Information
- **URL**: [Watch Video](${data.url})

## Transcript

${this.decodeHtmlEntities(data.transcript)}

## Notes

`;
	}

	onunload() {
		console.log("Unloading YouTubeTranscriptPlugin");
	}

	async saveSettings() {
		await this.saveData(this.settings);
	}

	private debug(...args: any[]): void {
		if (this.DEBUG) {
			console.log("[YT Transcript]", ...args);
		}
	}

	public sanitizeFileTitle(title: string): string {
		return title
			.replace(/[\\/:*?"<>|]/g, '')
			.replace(/\s+/g, ' ')
			.trim()
			.slice(0, 100);
	}

	private cleanYouTubeUrl(url: string): string {
		try {
			let videoId = '';
			
			// Handle youtu.be format
			if (url.includes('youtu.be/')) {
				videoId = url.split('youtu.be/')[1]?.split(/[?&]/)[0];
			} 
			// Handle youtube.com format
			else if (url.includes('youtube.com/watch')) {
				const urlParams = new URL(url).searchParams;
				videoId = urlParams.get('v') || '';
			}
			// Handle youtube.com/v/ format
			else if (url.includes('youtube.com/v/')) {
				videoId = url.split('youtube.com/v/')[1]?.split(/[?&]/)[0];
			}

			if (!videoId || videoId.length !== 11) {
				throw new Error("Could not extract valid YouTube video ID");
			}

			// Return clean YouTube URL in the format the API expects
			return `https://youtu.be/${videoId}`;  // Changed to youtu.be format
		} catch (error: unknown) {
			if (error instanceof Error) {
				throw new Error(`Invalid YouTube URL: ${error.message}`);
			}
			throw new Error('Invalid YouTube URL: Unknown error');
		}
	}
}

class YouTubeTranscriptModal extends Modal {
	plugin: YouTubeTranscriptPlugin;

	constructor(app: App, plugin: YouTubeTranscriptPlugin) {
		super(app);
		this.plugin = plugin;
	}

	private getFormattedDateTime(): string {
		const now = new Date();
		const date = now.toISOString().split('T')[0];
		const time = now.toTimeString()
			.split(' ')[0]
			.replace(/:/g, '-');
		return `${date}-${time}`;
	}

	private sanitizeFileName(name: string): string {
		return name.replace(/[\\/:*?"<>|]/g, '-');
	}

	private sanitizeFileTitle(title: string): string {
		return title
			.replace(/[\\/:*?"<>|]/g, '')
			.replace(/[^\w\s-]/g, '')
			.replace(/\s+/g, ' ')
			.trim()
			.slice(0, 100);
	}

	onOpen() {
		const { contentEl } = this;
		contentEl.createEl("h2", { text: "Enter YouTube URL" });

		const urlInput = new Setting(contentEl)
			.setName("URL")
			.addText((text) =>
				text.setPlaceholder("Paste URL").onChange((value) => {})
			);

		new Setting(contentEl).addButton((btn) =>
			btn
				.setButtonText("Fetch Transcript")
				.setCta()
				.onClick(async () => {
					const url = urlInput.controlEl.querySelector("input")?.value ?? "";
					if (!url.trim()) {
						new Notice("Please enter a YouTube URL");
						return;
					}

					if (!url.includes('youtube.com') && !url.includes('youtu.be')) {
						new Notice("Please enter a valid YouTube URL");
						return;
					}
					
					new Notice("Fetching transcript...");
					this.close();

					try {
						const transcript = await this.plugin.fetchTranscript(url);
						if (!transcript) {
							throw new Error("No transcript content received");
						}

						const titleMatch = transcript.match(/^title: (.+)$/m);
						const videoTitle = titleMatch ? 
							titleMatch[1] : 
							'Untitled Video';

						const safeTitle = this.sanitizeFileTitle(videoTitle)
							.replace(/\s+/g, '-');

						const noteName = `YT - ${safeTitle}.md`;
						
						const folderPath = this.sanitizeFileName(this.plugin.settings.noteFolder || "YouTube Transcripts");
						
						if (folderPath && !(await this.app.vault.adapter.exists(folderPath))) {
							await this.app.vault.createFolder(folderPath);
						}
						
						const filePath = `${folderPath}/${noteName}`;
						
						try {
							const newFile: TFile = await this.app.vault.create(filePath, transcript);
							new Notice(`Transcript saved to: ${newFile.path}`);
						} catch (fileError) {
							console.error("File creation error:", fileError);
							new Notice("Error saving transcript. The file name might be invalid.");
						}
					} catch (err) {
						console.error(err);
						new Notice(`Error: ${err instanceof Error ? err.message : "Failed to fetch transcript"}`);
					}
				})
		);
	}

	onClose() {
		const { contentEl } = this;
		contentEl.empty();
	}
}

class YouTubeTranscriptPluginSettingTab extends PluginSettingTab {
	plugin: YouTubeTranscriptPlugin;

	constructor(app: App, plugin: YouTubeTranscriptPlugin) {
		super(app, plugin);
		this.plugin = plugin;
	}

	display(): void {
		const { containerEl } = this;
		containerEl.empty();
		containerEl.createEl("h2", { text: "YouTube Transcript Plugin Settings" });

		new Setting(containerEl)
			.setName("Transcript Note Folder")
			.setDesc("Folder to store transcript notes (leave blank for vault root).")
			.addText((text) =>
				text
					.setPlaceholder("e.g. Transcripts")
					.setValue(this.plugin.settings.noteFolder)
					.onChange(async (value) => {
						this.plugin.settings.noteFolder = value.trim();
						await this.plugin.saveSettings();
					})
			);
	}
}