YouTube.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Windows.Forms;
using static GenerallyPositive.Enums;
using GenerallyPositive;
 
namespace GenerallyPositive.Browser
{
    public readonly struct PremiereTime
    {
        private readonly bool     _isRelative;
        private readonly DateTime _absolute;
        private readonly TimeSpan _offset;
 
        private PremiereTime(TimeSpan offset)   { _isRelative = true;  _offset   = offset;                                                        _absolute = default; }
        private PremiereTime(DateTime absolute) { _isRelative = false; _absolute = absolute.Kind == DateTimeKind.Utc ? absolute : absolute.ToUniversalTime(); _offset = default; }
 
        public static PremiereTime In1Minute   => new PremiereTime(TimeSpan.FromMinutes(1));
        public static PremiereTime In5Minutes  => new PremiereTime(TimeSpan.FromMinutes(5));
        public static PremiereTime In10Minutes => new PremiereTime(TimeSpan.FromMinutes(10));
        public static PremiereTime In15Minutes => new PremiereTime(TimeSpan.FromMinutes(15));
        public static PremiereTime In30Minutes => new PremiereTime(TimeSpan.FromMinutes(30));
        public static PremiereTime In45Minutes => new PremiereTime(TimeSpan.FromMinutes(45));
        public static PremiereTime In1Hour     => new PremiereTime(TimeSpan.FromHours(1));
 
        public static PremiereTime At(DateTime dt) => new PremiereTime(dt);
 
        internal DateTime Resolve() => _isRelative ? DateTime.UtcNow.Add(_offset) : _absolute;
 
        public static implicit operator DateTime(PremiereTime pt) => pt.Resolve();
 
        public override string ToString() => _isRelative
            ? $"In {(int)_offset.TotalMinutes} minutes"
            : _absolute.ToString("o");
    }

    public class YouTubePlaylistResult
    {
        public string PlaylistId { get; }
        public string Url        { get; }
        internal YouTubePlaylistResult(string playlistId)
        {
            PlaylistId = playlistId;
            Url        = $"https://www.youtube.com/playlist?list={playlistId}";
        }
    }

    public class YouTubeVideoInfo
    {
        public string    VideoId     { get; }
        public string    Title       { get; }
        public string    Description { get; }
        public string[]  Tags        { get; }
        public string    Url         { get; }
        public DateTime? PublishedAt { get; }
        internal YouTubeVideoInfo(string videoId, string title, string description, string[] tags, DateTime? publishedAt)
        {
            VideoId     = videoId;
            Title       = title       ?? string.Empty;
            Description = description ?? string.Empty;
            Tags        = tags        ?? new string[0];
            Url         = $"https://youtu.be/{videoId}";
            PublishedAt = publishedAt;
        }
    }

    public class YouTubeUploadResult
    {
        public string VideoId { get; }
        public string Url     { get; }
        public string Status  { get; }
 
        internal YouTubeUploadResult(string videoId, string url, string status)
        {
            VideoId = videoId;
            Url     = url;
            Status  = status;
        }
    }

    public class GPALYouTube : IGPALYouTube
    {
        private ICredentials             _credentials;
        private string                   _title             = string.Empty;
        private string                   _description       = string.Empty;
        private string[]                 _tags              = new string[0];
        private YouTubePrivacy           _privacy           = YouTubePrivacy.Private;
        private YouTubeCategory          _category          = YouTubeCategory.ScienceTechnology;
        private List<string>             _videoIds          = new List<string>();
        private int                      _pollIntervalSecs  = 60;
        private TextBoxBase              _outputControl;
        private ManualResetEventSlim     _completionEvent   = new ManualResetEventSlim(false);
        private string                   _playlistId        = null;
        private List<string>             _lookupVideoIds    = new List<string>();
        private List<string>             _searchTerms       = new List<string>();
 
        private const string InitiationUrl    = "https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status";
        private const string VideoStatusUrl   = "https://www.googleapis.com/youtube/v3/videos?part=status&id=";
        private const string VideoUpdateUrl   = "https://www.googleapis.com/youtube/v3/videos?part=status";
        private const string PlaylistCreateUrl = "https://www.googleapis.com/youtube/v3/playlists?part=snippet,status";
        private const string PlaylistItemUrl   = "https://www.googleapis.com/youtube/v3/playlistItems?part=snippet";
        private const string VideoInfoBaseUrl  = "https://www.googleapis.com/youtube/v3/videos?part=snippet&id=";
        private const string SearchBaseUrl     = "https://www.googleapis.com/youtube/v3/search?part=snippet&type=video&forMine=true&maxResults=50&q=";
 
        internal GPALYouTube() { }
 
        // ── Upload chain ──────────────────────────────────────────────────────
 
        public IGPALYouTube WithCredentials(ICredentials credentials)
        {
            if (credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "Credentials is null.", this, GPALObjectType.YouTube);
                return this;
            }
            _credentials = credentials;
            GPAL.PublishSimpleEvent(GPALEventType.INFO, "Credentials configured.", this, GPALObjectType.YouTube);
            return this;
        }
 
        public IGPALYouTube WithTitle(string title)
        {
            _title = title ?? string.Empty;
            return this;
        }
 
        public IGPALYouTube WithDescription(string description)
        {
            _description = description ?? string.Empty;
            return this;
        }
 
        public IGPALYouTube WithTags(params string[] tags)
        {
            _tags = tags ?? new string[0];
            return this;
        }
 
        public IGPALYouTube WithPrivacy(YouTubePrivacy privacy)
        {
            _privacy = privacy;
            return this;
        }
 
        public IGPALYouTube WithCategory(YouTubeCategory category)
        {
            _category = category;
            return this;
        }
 
        public YouTubeUploadResult Upload(GPALFile file)
        {
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Credentials must be set before Upload.", this, GPALObjectType.YouTube);
                return null;
            }
 
            string filePath = file?.Filename;
            if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, $"File not found: [{filePath}]", this, GPALObjectType.YouTube);
                return null;
            }
 
            try
            {
                _credentials.FetchAccessToken(out string token);
                if (string.IsNullOrEmpty(token))
                {
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Failed to fetch access token.", this, GPALObjectType.YouTube);
                    return null;
                }
 
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Uploading: [{Path.GetFileName(filePath)}]", this, GPALObjectType.YouTube);
 
                string uploadUri = InitiateResumableUpload(token, filePath);
                if (string.IsNullOrEmpty(uploadUri)) return null;
 
                string videoId = UploadVideoBytes(uploadUri, filePath);
                if (string.IsNullOrEmpty(videoId)) return null;
 
                string url = $"https://youtu.be/{videoId}";
                GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Upload complete: [{url}]", this, GPALObjectType.YouTube);
                if (!string.IsNullOrEmpty(_playlistId))
                    AddVideoToPlaylist(token, _playlistId, videoId);
                return new YouTubeUploadResult(videoId, url, "uploaded");
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "YouTube upload failed.", this, GPALObjectType.YouTube, ex);
                return null;
            }
        }
 
        // ── Schedule chain ────────────────────────────────────────────────────
 
        public IGPALYouTube WithVideo(YouTubeUploadResult result)
        {
            if (result == null || string.IsNullOrEmpty(result.VideoId))
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "WithVideo: null or missing VideoId.", this, GPALObjectType.YouTube);
                return this;
            }
            _videoIds.Add(result.VideoId);
            return this;
        }
 
        public IGPALYouTube WithVideos(IEnumerable<YouTubeUploadResult> results)
        {
            if (results == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "WithVideos: null results list.", this, GPALObjectType.YouTube);
                return this;
            }
            foreach (var r in results)
                if (r != null && !string.IsNullOrEmpty(r.VideoId))
                    _videoIds.Add(r.VideoId);
            return this;
        }
 
        public IGPALYouTube WaitForProcessing(int pollIntervalSeconds = 60)
        {
            _pollIntervalSecs = Math.Max(10, pollIntervalSeconds);
            return this;
        }

        public IGPALYouTube ScheduleAt(PremiereTime premiereTime)
        {
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "ScheduleAt: credentials not set.", this, GPALObjectType.YouTube);
                return this;
            }
            if (_videoIds.Count == 0)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "ScheduleAt: no videos targeted. Call WithVideo or WithVideos first.", this, GPALObjectType.YouTube);
                return this;
            }
 
            // Capture everything the background thread needs; don't close over mutable fields
            var videoIds   = new List<string>(_videoIds);
            var creds      = _credentials;
            var intervalMs = _pollIntervalSecs * 1000;
 
            var thread = new Thread(() => PollAndSchedule(creds, videoIds, premiereTime, intervalMs));
            thread.IsBackground = true;
            thread.Start();
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                $"ScheduleAt started in background for [{videoIds.Count}] video(s). Poll interval: [{_pollIntervalSecs}]s.",
                this, GPALObjectType.YouTube);
 
            return this;
        }
 
        // ── Output and completion ─────────────────────────────────────────────

        public IGPALYouTube WithOutputTo(TextBoxBase control)
        {
            _outputControl = control;
            return this;
        }

        public void WaitForCompletion()
        {
            _completionEvent.Wait();
        }
 
        private void AppendToOutput(string message)
        {
            if (_outputControl == null) return;
            if (_outputControl.InvokeRequired)
                _outputControl.BeginInvoke(new Action(() => AppendToOutput(message)));
            else
                _outputControl.AppendText(message + Environment.NewLine);
        }
 
        // ── Background polling ────────────────────────────────────────────────
 
        private void PollAndSchedule(ICredentials creds, List<string> videoIds, PremiereTime premiereTime, int intervalMs)
        {
            var pending    = new HashSet<string>(videoIds);
            var lastStatus = new Dictionary<string, string>();
 
            string openingMsg = $"Suppressing repeat status messages for: {string.Join(", ", videoIds)}. Will report when processing completes for each.";
            GPAL.PublishSimpleEvent(GPALEventType.INFO, openingMsg, this, GPALObjectType.YouTube);
            AppendToOutput(openingMsg);
 
            while (pending.Count > 0)
            {
                creds.FetchAccessToken(out string token);
 
                var justProcessed = new List<string>();
 
                foreach (string id in new List<string>(pending))
                {
                    string status = GetUploadStatus(token, id);
 
                    string prev;
                    if (!lastStatus.TryGetValue(id, out prev) || prev != status)
                    {
                        string msg = $"Video {id}: {status}";
                        GPAL.PublishSimpleEvent(GPALEventType.INFO, msg, this, GPALObjectType.YouTube);
                        AppendToOutput(msg);
                        lastStatus[id] = status;
                    }
 
                    if (status == "processed")
                    {
                        justProcessed.Add(id);
                    }
                    else if (status == "failed" || status == "rejected" || status == "deleted")
                    {
                        string errMsg = $"Video {id} cannot be scheduled: {status}.";
                        GPAL.PublishSimpleEvent(GPALEventType.ERROR, errMsg, this, GPALObjectType.YouTube);
                        AppendToOutput(errMsg);
                        justProcessed.Add(id);
                    }
                }
 
                foreach (string id in justProcessed)
                {
                    pending.Remove(id);
                    string finalStatus;
                    if (lastStatus.TryGetValue(id, out finalStatus) && finalStatus == "processed")
                    {
                        DateTime pt = premiereTime.Resolve();
                        SetPremiere(token, id, pt);
                    }
                }
 
                if (pending.Count > 0)
                    Thread.Sleep(intervalMs);
            }
 
            string doneMsg = "All videos scheduled.";
            GPAL.PublishSimpleEvent(GPALEventType.INFO, doneMsg, this, GPALObjectType.YouTube);
            AppendToOutput(doneMsg);
            _completionEvent.Set();
        }
 
        private void SetPremiere(string token, string videoId, DateTime premiereUtc)
        {
            try
            {
                string body = "{\"id\":" + JsonString(videoId)
                    + ",\"status\":{\"privacyStatus\":\"private\",\"publishAt\":" + JsonString(premiereUtc.ToString("o")) + "}}";
                byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
 
                var req = (HttpWebRequest)WebRequest.Create(VideoUpdateUrl);
                req.Method        = "PUT";
                req.Headers["Authorization"] = "Bearer " + token;
                req.ContentType   = "application/json";
                req.ContentLength = bodyBytes.Length;
 
                using (var s = req.GetRequestStream())
                    s.Write(bodyBytes, 0, bodyBytes.Length);
 
                using ((HttpWebResponse)req.GetResponse()) { }
 
                string schedMsg = $"Premiere scheduled: https://youtu.be/{videoId} at {premiereUtc:o}";
                GPAL.PublishSimpleEvent(GPALEventType.INFO, schedMsg, this, GPALObjectType.YouTube);
                AppendToOutput(schedMsg);
            }
            catch (Exception ex)
            {
                string errMsg = $"SetPremiere failed for {videoId}.";
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, errMsg, this, GPALObjectType.YouTube, ex);
                AppendToOutput(errMsg);
            }
        }
 
        private string GetUploadStatus(string token, string videoId)
        {
            try
            {
                var req = (HttpWebRequest)WebRequest.Create(VideoStatusUrl + videoId);
                req.Method = "GET";
                req.Headers["Authorization"] = "Bearer " + token;
 
                using (var resp   = (HttpWebResponse)req.GetResponse())
                using (var reader = new StreamReader(resp.GetResponseStream()))
                {
                    string responseBody = reader.ReadToEnd();
                    using (var doc = JsonDocument.Parse(responseBody))
                    {
                        if (doc.RootElement.TryGetProperty("items", out var items)
                            && items.GetArrayLength() > 0
                            && items[0].TryGetProperty("status", out var status)
                            && status.TryGetProperty("uploadStatus", out var uploadStatus))
                        {
                            return uploadStatus.GetString();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"GetUploadStatus failed for [{videoId}].", this, GPALObjectType.YouTube, ex);
            }
            return "unknown";
        }
 
        // ── Upload internals ──────────────────────────────────────────────────
 
        private string InitiateResumableUpload(string token, string filePath)
        {
            long   fileSize = new FileInfo(filePath).Length;
            byte[] body     = Encoding.UTF8.GetBytes(BuildMetadataJson());
 
            var req = (HttpWebRequest)WebRequest.Create(InitiationUrl);
            req.Method = "POST";
            req.Headers["Authorization"]           = "Bearer " + token;
            req.ContentType                        = "application/json; charset=UTF-8";
            req.Headers["X-Upload-Content-Type"]   = "video/mp4";
            req.Headers["X-Upload-Content-Length"] = fileSize.ToString();
            req.ContentLength = body.Length;
 
            using (var s = req.GetRequestStream())
                s.Write(body, 0, body.Length);
 
            try
            {
                using (var resp = (HttpWebResponse)req.GetResponse())
                {
                    string uri = resp.Headers["Location"];
                    GPAL.PublishSimpleEvent(GPALEventType.INFO, "Resumable upload session started.", this, GPALObjectType.YouTube);
                    return uri;
                }
            }
            catch (WebException wex) when (wex.Response is HttpWebResponse errResp)
            {
                using (var reader = new System.IO.StreamReader(errResp.GetResponseStream()))
                {
                    string detail = reader.ReadToEnd();
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, $"Upload initiation failed ([{(int)errResp.StatusCode}]): [{detail}]", this, GPALObjectType.YouTube);
                }
                throw;
            }
        }
 
        private string UploadVideoBytes(string uploadUri, string filePath)
        {
            long fileSize = new FileInfo(filePath).Length;
 
            var req = (HttpWebRequest)WebRequest.Create(uploadUri);
            req.Method                    = "PUT";
            req.ContentType               = "video/mp4";
            req.ContentLength             = fileSize;
            req.Timeout                   = 3_600_000;
            req.AllowWriteStreamBuffering = false;
 
            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"Sending [{fileSize:N0}] bytes...", this, GPALObjectType.YouTube);
 
            using (var reqStream = req.GetRequestStream())
            using (var fs        = File.OpenRead(filePath))
            {
                byte[] buf = new byte[256 * 1024];
                int read;
                while ((read = fs.Read(buf, 0, buf.Length)) > 0)
                    reqStream.Write(buf, 0, read);
            }
 
            using (var resp   = (HttpWebResponse)req.GetResponse())
            using (var reader = new StreamReader(resp.GetResponseStream()))
            {
                string responseBody = reader.ReadToEnd();
                using (var doc = JsonDocument.Parse(responseBody))
                {
                    if (doc.RootElement.TryGetProperty("id", out var idEl))
                        return idEl.GetString();
                }
            }
 
            GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Upload response missing video ID.", this, GPALObjectType.YouTube);
            return null;
        }
 
        private string PrivacyString()
        {
            switch (_privacy)
            {
                case YouTubePrivacy.Public:   return "public";
                case YouTubePrivacy.Unlisted: return "unlisted";
                default:                      return "private";
            }
        }
 
        private string BuildMetadataJson()
        {
            string privacyStr = PrivacyString();
 
            var tags = new StringBuilder("[");
            for (int i = 0; i < _tags.Length; i++)
            {
                if (i > 0) tags.Append(",");
                tags.Append(JsonString(_tags[i]));
            }
            tags.Append("]");
 
            return "{\"snippet\":{\"title\":"       + JsonString(_title)
                + ",\"description\":"               + JsonString(_description)
                + ",\"tags\":"                      + tags
                + ",\"categoryId\":"                + JsonString(((int)_category).ToString())
                + "},\"status\":{\"privacyStatus\":" + JsonString(privacyStr) + "}}";
        }
 
        private static string JsonString(string s)
        {
            if (s == null) return "\"\"";
            return "\"" + s.Replace("\\", "\\\\")
                           .Replace("\"", "\\\"")
                           .Replace("\n", "\\n")
                           .Replace("\r", "\\r")
                           .Replace("\t", "\\t")
                 + "\"";
        }
 
        // ── Playlist ──────────────────────────────────────────────────────────
 
        public IGPALYouTube WithPlaylist(string playlistId)
        {
            _playlistId = playlistId;
            return this;
        }
 
        public YouTubePlaylistResult CreatePlaylist()
        {
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "CreatePlaylist: credentials not set.", this, GPALObjectType.YouTube);
                return null;
            }
            try
            {
                _credentials.FetchAccessToken(out string token);
                if (string.IsNullOrEmpty(token))
                {
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, "CreatePlaylist: failed to fetch access token.", this, GPALObjectType.YouTube);
                    return null;
                }
 
                string body = "{\"snippet\":{\"title\":" + JsonString(_title)
                    + ",\"description\":" + JsonString(_description)
                    + "},\"status\":{\"privacyStatus\":" + JsonString(PrivacyString()) + "}}";
                byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
 
                var req = (HttpWebRequest)WebRequest.Create(PlaylistCreateUrl);
                req.Method        = "POST";
                req.Headers["Authorization"] = "Bearer " + token;
                req.ContentType   = "application/json";
                req.ContentLength = bodyBytes.Length;
 
                using (var s = req.GetRequestStream())
                    s.Write(bodyBytes, 0, bodyBytes.Length);
 
                using (var resp   = (HttpWebResponse)req.GetResponse())
                using (var reader = new StreamReader(resp.GetResponseStream()))
                {
                    string responseBody = reader.ReadToEnd();
                    using (var doc = JsonDocument.Parse(responseBody))
                    {
                        if (doc.RootElement.TryGetProperty("id", out var idEl))
                        {
                            string playlistId = idEl.GetString();
                            GPAL.PublishSimpleEvent(GPALEventType.INFO,
                                $"Playlist created: https://www.youtube.com/playlist?list=[{playlistId}]", this, GPALObjectType.YouTube);
                            return new YouTubePlaylistResult(playlistId);
                        }
                    }
                }
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "CreatePlaylist: response missing playlist ID.", this, GPALObjectType.YouTube);
                return null;
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "CreatePlaylist failed.", this, GPALObjectType.YouTube, ex);
                return null;
            }
        }
 
        public IGPALYouTube AddToPlaylist(string playlistId)
        {
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "AddToPlaylist: credentials not set.", this, GPALObjectType.YouTube);
                return this;
            }
            if (_videoIds.Count == 0)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "AddToPlaylist: no videos. Call WithVideo or WithVideos first.", this, GPALObjectType.YouTube);
                return this;
            }
            _credentials.FetchAccessToken(out string token);
            foreach (string videoId in _videoIds)
                AddVideoToPlaylist(token, playlistId, videoId);
            return this;
        }
 
        private void AddVideoToPlaylist(string token, string playlistId, string videoId)
        {
            try
            {
                string body = "{\"snippet\":{\"playlistId\":" + JsonString(playlistId)
                    + ",\"resourceId\":{\"kind\":\"youtube#video\",\"videoId\":" + JsonString(videoId) + "}}}";
                byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
 
                var req = (HttpWebRequest)WebRequest.Create(PlaylistItemUrl);
                req.Method        = "POST";
                req.Headers["Authorization"] = "Bearer " + token;
                req.ContentType   = "application/json";
                req.ContentLength = bodyBytes.Length;
 
                using (var s = req.GetRequestStream())
                    s.Write(bodyBytes, 0, bodyBytes.Length);
 
                using ((HttpWebResponse)req.GetResponse()) { }
 
                GPAL.PublishSimpleEvent(GPALEventType.INFO,
                    $"Added [{videoId}] to playlist [{playlistId}].", this, GPALObjectType.YouTube);
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION,
                    $"AddVideoToPlaylist failed for [{videoId}].", this, GPALObjectType.YouTube, ex);
            }
        }
 
        // ── Lookup / Search ───────────────────────────────────────────────────
 
        public IGPALYouTube WithVideoId(string videoId)
        {
            if (!string.IsNullOrEmpty(videoId))
                _lookupVideoIds.Add(videoId);
            return this;
        }
 
        public IGPALYouTube WithSearchTerms(string query)
        {
            if (!string.IsNullOrEmpty(query))
                _searchTerms.Add(query);
            return this;
        }
 
        public IGPALYouTube WithSearchTerms(IGPALGrid<string> grid)
        {
            if (grid == null) return this;
            foreach (var row in grid)
                if (row != null && row.Count > 0 && !string.IsNullOrEmpty(row[0]))
                    _searchTerms.Add(row[0]);
            return this;
        }
 
        public IGPALYouTube GetResults(out YouTubeVideoInfo info)
        {
            info = null;
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "GetResults: credentials not set.", this, GPALObjectType.YouTube);
                return this;
            }
            if (_lookupVideoIds.Count == 0)
            {
                GPAL.PublishSimpleEvent(GPALEventType.WARNING, "GetResults: no video ID. Call WithVideoId first.", this, GPALObjectType.YouTube);
                return this;
            }
            _credentials.FetchAccessToken(out string token);
            var list = FetchVideoInfos(token, _lookupVideoIds);
            info = list.Count > 0 ? list[0] : null;
            return this;
        }
 
        public IGPALYouTube GetResults(out List<YouTubeVideoInfo> results)
        {
            results = new List<YouTubeVideoInfo>();
            if (_credentials == null)
            {
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "GetResults: credentials not set.", this, GPALObjectType.YouTube);
                return this;
            }
            _credentials.FetchAccessToken(out string token);
 
            if (_lookupVideoIds.Count > 0)
                results.AddRange(FetchVideoInfos(token, _lookupVideoIds));
 
            if (_searchTerms.Count > 0)
            {
                var seen = new HashSet<string>();
                foreach (var v in results) seen.Add(v.VideoId);
                foreach (string term in _searchTerms)
                {
                    foreach (var v in SearchVideos(token, term))
                        if (seen.Add(v.VideoId))
                            results.Add(v);
                }
            }
            return this;
        }
 
        private List<YouTubeVideoInfo> FetchVideoInfos(string token, List<string> videoIds)
        {
            var result = new List<YouTubeVideoInfo>();
            int i = 0;
            while (i < videoIds.Count)
            {
                var batch = new StringBuilder();
                int end = Math.Min(i + 50, videoIds.Count);
                for (int j = i; j < end; j++)
                {
                    if (j > i) batch.Append(",");
                    batch.Append(Uri.EscapeDataString(videoIds[j]));
                }
                i = end;
 
                try
                {
                    var req = (HttpWebRequest)WebRequest.Create(VideoInfoBaseUrl + batch);
                    req.Method = "GET";
                    req.Headers["Authorization"] = "Bearer " + token;
 
                    using (var resp   = (HttpWebResponse)req.GetResponse())
                    using (var reader = new StreamReader(resp.GetResponseStream()))
                    {
                        string responseBody = reader.ReadToEnd();
                        using (var doc = JsonDocument.Parse(responseBody))
                        {
                            if (!doc.RootElement.TryGetProperty("items", out var items)) continue;
                            foreach (var item in items.EnumerateArray())
                            {
                                string videoId = item.TryGetProperty("id", out var idEl) ? idEl.GetString() : null;
                                if (string.IsNullOrEmpty(videoId)) continue;
 
                                string title = string.Empty, description = string.Empty;
                                string[] tags = new string[0];
                                DateTime? publishedAt = null;
 
                                if (item.TryGetProperty("snippet", out var snippet))
                                {
                                    if (snippet.TryGetProperty("title",       out var t)) title       = t.GetString();
                                    if (snippet.TryGetProperty("description", out var d)) description = d.GetString();
                                    if (snippet.TryGetProperty("publishedAt", out var p)
                                        && DateTime.TryParse(p.GetString(), out DateTime dt))
                                        publishedAt = dt;
                                    if (snippet.TryGetProperty("tags", out var tagsEl))
                                    {
                                        var tagList = new List<string>();
                                        foreach (var tag in tagsEl.EnumerateArray())
                                            tagList.Add(tag.GetString());
                                        tags = tagList.ToArray();
                                    }
                                }
                                result.Add(new YouTubeVideoInfo(videoId, title, description, tags, publishedAt));
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, "FetchVideoInfos failed.", this, GPALObjectType.YouTube, ex);
                }
            }
            return result;
        }
 
        private List<YouTubeVideoInfo> SearchVideos(string token, string query)
        {
            var result = new List<YouTubeVideoInfo>();
            try
            {
                var req = (HttpWebRequest)WebRequest.Create(SearchBaseUrl + Uri.EscapeDataString(query));
                req.Method = "GET";
                req.Headers["Authorization"] = "Bearer " + token;
 
                using (var resp   = (HttpWebResponse)req.GetResponse())
                using (var reader = new StreamReader(resp.GetResponseStream()))
                {
                    string responseBody = reader.ReadToEnd();
                    using (var doc = JsonDocument.Parse(responseBody))
                    {
                        if (!doc.RootElement.TryGetProperty("items", out var items)) return result;
                        foreach (var item in items.EnumerateArray())
                        {
                            string videoId = null;
                            if (item.TryGetProperty("id", out var idObj)
                                && idObj.TryGetProperty("videoId", out var vidEl))
                                videoId = vidEl.GetString();
                            if (string.IsNullOrEmpty(videoId)) continue;
 
                            string title = string.Empty, description = string.Empty;
                            DateTime? publishedAt = null;
 
                            if (item.TryGetProperty("snippet", out var snippet))
                            {
                                if (snippet.TryGetProperty("title",       out var t)) title       = t.GetString();
                                if (snippet.TryGetProperty("description", out var d)) description = d.GetString();
                                if (snippet.TryGetProperty("publishedAt", out var p)
                                    && DateTime.TryParse(p.GetString(), out DateTime dt))
                                    publishedAt = dt;
                            }
                            result.Add(new YouTubeVideoInfo(videoId, title, description, null, publishedAt));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"SearchVideos failed for [{query}].", this, GPALObjectType.YouTube, ex);
            }
            return result;
        }
    }
}