public Video GetById(string id)
 {
     var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri + "/" + id);
     var res = GetVideos(query);
     var v = res.FirstOrDefault();
     return v;
 }

        public IEnumerable<VideoModel> Search(string searchText)
        {
            var modelList = new List<VideoModel>();
            var settings = new YouTubeRequestSettings("YouTunes", "AIzaSyCgNs6G_0w36g6dhAxxBL4nL7wD3C6jmOw");
            var request = new YouTubeRequest(settings);
            var query = new YouTubeQuery("https://gdata.youtube.com/feeds/api/videos") { Query = searchText };

            Feed<Video> feed = null;

            try
            {
                feed = request.Get<Video>(query);

                foreach (var video in feed.Entries)
                {
                    modelList.Add(new VideoModel() { VideoTitle = video.Title, VideoId = video.VideoId });
                }
            }
            catch (GDataRequestException gdre)
            {

            }

            return modelList;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Uri ur = new Uri("http://gdata.youtube.com/feeds/api/videos/fSgGV1llVHM&f=gdata_playlists&c=ytapi-DukaIstvan-MyYouTubeVideosF-d1ogtvf7-0&d=U1YkMvELc_arPNsH4kYosmD9LlbsOl3qUImVMV6ramM");
              YouTubeQuery query = new YouTubeQuery("http://gdata.youtube.com/feeds/api/channels?q=vevo");

              YouTubeFeed videoFeed = service.Query(query);
              YouTubeEntry en = (YouTubeEntry)videoFeed.Entries[0];

              Video video = request.Retrieve<Video>(new Uri("http://gdata.youtube.com/feeds/api/videos/" + en.VideoId));
              Feed<Comment> comments = request.GetComments(video);
            string cm = "";
            foreach (Comment c in comments.Entries)
            {
              cm +=  c.Content + "\n------------------------------------------\n";
            }

              VideoInfo info = new VideoInfo();
              info.Get("yUHNUjEs7rQ");
              //Video v = request.Retrieve<Video>(videoEntryUrl);

              //Feed<Comment> comments = request.GetComments(v);

              //string cm = "";
              //foreach (Comment c in comments.Entries)
              //{
              //  cm += c.Author + c.Content + "------------------------------------------";
              //}
        }

        private static IObservable<IReadOnlyList<ISong>> RealSearch(string searchTerm)
        {
            var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri)
            { 
                OrderBy = "relevance",
                Query = searchTerm,
                SafeSearch = YouTubeQuery.SafeSearchValues.None,
                NumberToRetrieve = RequestLimit
            };

            var settings = new YouTubeRequestSettings("Espera", ApiKey);
            var request = new YouTubeRequest(settings);

            return Observable.FromAsync(async () =>
            {
                Feed<Video> feed = await Task.Run(() => request.Get<Video>(query));
                List<Video> entries = await Task.Run(() => feed.Entries.ToList());

                return (from video in entries
                    let url = video.WatchPage.OriginalString.Replace("&feature=youtube_gdata_player", String.Empty).Replace("https://", "http://")
                    select new YoutubeSong()
                    {
                        Artist = video.Uploader, Title = video.Title, OriginalPath = url
                    }).ToList();
            })
            .Catch<IReadOnlyList<YoutubeSong>, Exception>(ex => Observable.Throw<IReadOnlyList<YoutubeSong>>(new Exception("YoutubeSongFinder search failed", ex)));
        }

        protected void BBuscador(String track)
        {
            string spotUrl = String.Format("http://ws.spotify.com/search/1/track?q={0}", track);
            WebClient spotService = new WebClient();
            spotService.Encoding = Encoding.UTF8;
            spotService.DownloadStringCompleted += new DownloadStringCompletedEventHandler(SpotService_DownloadTracksCompleted);
            spotService.DownloadStringAsync(new Uri(spotUrl));

            YouTubeRequest request = new YouTubeRequest(settings);
            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            query.OrderBy = "relevance";
            query.Query = track;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            Feed<Video> videoFeed = request.Get<Video>(query);
            if (videoFeed.Entries.Count() > 0)
            {
                video1 = videoFeed.Entries.ElementAt(0);
                literal1.Text = String.Format(embed, video1.VideoId);
                if (videoFeed.Entries.Count() > 1)
                {
                    video1 = videoFeed.Entries.ElementAt(1);
                    literal1.Text += String.Format(embed, video1.VideoId);
                }
            }
        }

        public void Skype_MessageStatus(IChatMessage message, TChatMessageStatus status) {
            Match output = Regex.Match(message.Body, @"(?:youtube\.\w{2,3}\S+v=|youtu\.be/)([\w-]+)", RegexOptions.IgnoreCase);
            // Use non-breaking space as a marker for when to not show info.
            if (output.Success && !message.Body.Contains(" ")) {
                String youtubeId = output.Groups[1].Value;
                log.Info("Sending request to YouTube...");

                YouTubeQuery ytq = new YouTubeQuery("http://gdata.youtube.com/feeds/api/videos/" + youtubeId);

                Feed<Video> feed = ytr.Get<Video>(ytq);
                Video vid = feed.Entries.ElementAt<Video>(0);
                String title = vid.Title;
                String user = vid.Author;
                String rating = vid.RatingAverage.ToString();

                int seconds = Int32.Parse(vid.Media.Duration.Seconds) % 60;
                int minutes = Int32.Parse(vid.Media.Duration.Seconds) / 60;
                String duration = String.Format(@"{0}:{1:00}", minutes, seconds);

                message.Chat.SendMessage(String.Format(@"YouTube: ""{0}"" (uploaded by: {1}) (avg rating: {2:F2}) (duration: {3})", title, user, rating, duration));
                return;
            }
            
            output = Regex.Match(message.Body, @"^!youtube (.+)", RegexOptions.IgnoreCase);
            if (output.Success) {
                String query = output.Groups[1].Value;

                YouTubeQuery ytq = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
                ytq.Query = query;
                ytq.SafeSearch = YouTubeQuery.SafeSearchValues.None;
                ytq.NumberToRetrieve = 10;

                Feed<Video> feed = ytr.Get<Video>(ytq);
                int count = feed.Entries.Count<Video>();

                string url;
                if (count > 0) {
                    Video vid = feed.Entries.ElementAt<Video>(random.Next(count));
                    url = vid.WatchPage.ToString();
                } else {
                    url = "No matches found.";
                }

                message.Chat.SendMessage(String.Format(@"YouTube search for ""{0}"": {1}", query, url));
                return;
            }

            output = Regex.Match(message.Body, @"^!youtube", RegexOptions.IgnoreCase);
            if (output.Success) {
                log.Debug("Got a request for a random video.");

                String url = randomCache.Count > 0 ? randomCache.Dequeue() : generateRandomVideos(true);

                message.Chat.SendMessage(String.Format(@"Random YouTube video: {0}", url));

                generateRandomVideos(false);
                return;
            }
        }

 public void TimeTest()
 {
     YouTubeQuery target = new YouTubeQuery(); // TODO: Initialize to an appropriate value
     YouTubeQuery.UploadTime expected = new YouTubeQuery.UploadTime(); // TODO: Initialize to an appropriate value
     YouTubeQuery.UploadTime actual;
     target.Time = expected;
     actual = target.Time;
     Assert.AreEqual(expected, actual);
 }

 public void VQTest()
 {
     YouTubeQuery target = new YouTubeQuery(); // TODO: Initialize to an appropriate value
     string expected = "secret text string"; // TODO: Initialize to an appropriate value
     string actual;
     target.VQ = expected;
     actual = target.VQ;
     Assert.AreEqual(expected, actual);
 }

 // Search for a video given a keyword
 // @return feed of retrieved videos
 public static Feed<Video> SearchForVideo(string keyword)
 {
     YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
     query.OrderBy = "relevance";
     query.Query = keyword;
     query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
     query.NumberToRetrieve = 10;
     return request.Get<Video>(query);
 }

        public void PerformSearch (string searchVal)
        {
            YouTubeQuery query = new YouTubeQuery (YouTubeQuery.DefaultVideoUri);

            //order results by the number of views (most viewed first)
            query.OrderBy = "relevance";

            // perform querying with restricted content included in the results
            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            query.Query = searchVal;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;

            this.video_results = yt_request.Get<Video> (query);
        }

 private static IEnumerable<Video> GetVideos(YouTubeQuery q)
 {
     YouTubeRequest request = GetRequest();
     Feed<Video> feed = null;
     try
     {
         feed = request.Get<Video>(q);
     }
     catch (GDataRequestException gdre)
     {
         var response = (HttpWebResponse)gdre.Response;
     }
     return feed != null ? feed.Entries : null;
 }

        private void AddVideo(YouTubeRequest request, string maxResultsKey, string query, VideoList videoList)
        {
            int maxResults = ConfigService.GetConfig(maxResultsKey, 0);
            if (maxResults > 0)
            {
                YouTubeQuery youtubeQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
                youtubeQuery.Query = "%22" + query +  "%22";
                youtubeQuery.SafeSearch = YouTubeQuery.SafeSearchValues.Strict;
                youtubeQuery.NumberToRetrieve = maxResults;
                Feed<Video> videos = request.Get<Video>(youtubeQuery);

                YouTubeVideoParser parser = new YouTubeVideoParser();
                parser.Parse(videos, videoList);
            }
        }

        // once you copied your access and refresh tokens
        // then you can run this method directly from now on...
        public void MainX(string args)
        {
            GOAuth2RequestFactory requestFactory = RefreshAuthenticate();
            YouTubeRequestSettings settings = new YouTubeRequestSettings(_app_name, _clientID, _devKey);
            YouTubeRequest request = new YouTubeRequest(settings);

            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            //order results by the number of views (most viewed first)
            query.OrderBy = "viewCount";
            // search for puppies and include restricted content in the search results
            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            query.Query = args;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            //Feed<Video> videoFeed = requestFactory.Get<Video>(query);
        }

        public IEnumerable<MediaItemViewModel> Search(string query)
        {
            YouTubeQuery youtubeQuery = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
            //order results by the number of views (most viewed first)
            youtubeQuery.OrderBy = "viewCount";

            // query.SafeSearch could also be set to YouTubeQuery.SafeSearchValues.Moderate
            youtubeQuery.Query = query;
            youtubeQuery.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            youtubeQuery.NumberToRetrieve = 20;

            return this.Request.Get<Video>(youtubeQuery)
                .Entries
                .AsQueryable()
                .Project()
                .To<MediaItemViewModel>();
        }

        private static IObservable<IReadOnlyList<YoutubeSong>> RealSearch(string searchTerm)
        {
            var query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri)
            {
                OrderBy = "relevance",
                Query = searchTerm,
                SafeSearch = YouTubeQuery.SafeSearchValues.None,
                NumberToRetrieve = RequestLimit
            };

            // NB: I have no idea where this API blocks exactly
            var settings = new YouTubeRequestSettings("Espera", ApiKey);
            var request = new YouTubeRequest(settings);

            return Observable.FromAsync(async () =>
            {
                Feed<Video> feed = await Task.Run(() => request.Get<Video>(query));
                List<Video> entries = await Task.Run(() => feed.Entries.ToList());

                var songs = new List<YoutubeSong>();

                foreach (Video video in entries)
                {
                    var duration = TimeSpan.FromSeconds(Int32.Parse(video.YouTubeEntry.Duration.Seconds));
                    string url = video.WatchPage.OriginalString
                        .Replace("&feature=youtube_gdata_player", String.Empty) // Unnecessary long url
                        .Replace("https://", "http://"); // Secure connections are not always easy to handle when streaming

                    var song = new YoutubeSong(url, duration)
                    {
                        Artist = video.Uploader,
                        Title = video.Title,
                        Description = video.Description,
                        Rating = video.RatingAverage >= 1 ? video.RatingAverage : (double?)null,
                        ThumbnailSource = new Uri(video.Thumbnails[0].Url),
                        Views = video.ViewCount
                    };

                    songs.Add(song);
                }

                return songs;
            })
                // The API gives no clue what can throw, wrap it all up
            .Catch<IReadOnlyList<YoutubeSong>, Exception>(ex => Observable.Throw<IReadOnlyList<YoutubeSong>>(new NetworkSongFinderException("YoutubeSongFinder search failed", ex)));
        }

        public void YouTubeQueryTest() {
            Tracing.TraceMsg("Entering YouTubeQueryTest");

            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);

            query.Formats.Add(YouTubeQuery.VideoFormat.RTSP);
            query.Formats.Add(YouTubeQuery.VideoFormat.Mobile);

            query.Time = YouTubeQuery.UploadTime.ThisWeek;

            Assert.AreEqual(query.Uri.AbsoluteUri, YouTubeQuery.DefaultVideoUri + "?format=1%2C6&time=this_week", "Video query should be identical");

            query = new YouTubeQuery();
            query.Uri = new Uri("https://www.youtube.com/feeds?format=1&time=this_week&racy=included");

            Assert.AreEqual(query.Time, YouTubeQuery.UploadTime.ThisWeek, "Should be this week");
            Assert.AreEqual(query.Formats[0], YouTubeQuery.VideoFormat.RTSP, "Should be RTSP");
        }

        public static Feed<Google.YouTube.Video> GetCurtVideos()
        {
            try {
                YouTubeRequestSettings settings = new YouTubeRequestSettings("eLocal", "AI39si6iCFZ_NutrvZe04i9_m7gFhgmPK1e7LF6-yHMAwB-GDO3vC3eD0R-5lberMQLdglNjH3IWUMe3tJXe9qrFe44n2jAUyg");
                YouTubeRequest req = new YouTubeRequest(settings);

                YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
                query.Author = "curtmfg";
                query.Formats.Add(YouTubeQuery.VideoFormat.Embeddable);
                query.OrderBy = "viewCount";

                // We need to load the feed data for the CURTMfg Youtube Channel
                Feed<Google.YouTube.Video> video_feed = req.Get<Google.YouTube.Video>(query);
                return video_feed;
            } catch (Exception) {
                return null;
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Uri ur =
            new Uri(
              "http://gdata.youtube.com/feeds/api/videos/fSgGV1llVHM&f=gdata_playlists&c=ytapi-DukaIstvan-MyYouTubeVideosF-d1ogtvf7-0&d=U1YkMvELc_arPNsH4kYosmD9LlbsOl3qUImVMV6ramM");
              YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);
              //order results by the number of views (most viewed first)
              query.OrderBy = "viewCount";

              //exclude restricted content from the search
              query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
              //string ss = YouTubeQuery.TopRatedVideo;
              //http://gdata.youtube.com/feeds/api/standardfeeds/top_rated
              //search for puppies!
              query.Query = textBox1.Text;
              query.Categories.Add(new QueryCategory("Music", QueryCategoryOperator.AND));

              YouTubeFeed videoFeed = service.Query(query);
              YouTubeEntry en = (YouTubeEntry) videoFeed.Entries[0];
              string s = en.Summary.Text;
              string s1 = en.Media.Description.Value;
              Google.GData.YouTube.MediaGroup gr = en.Media;

              Uri videoEntryUrl = new Uri("http://gdata.youtube.com/feeds/api/videos/" + en.VideoId);
              Video video = request.Retrieve<Video>(videoEntryUrl);
              Feed<Comment> comments = request.GetComments(video);
              string cm = "";
              foreach (Comment c in comments.Entries)
              {
            cm += c.Content + "\n------------------------------------------\n";
              }

              VideoInfo info = new VideoInfo();
              info.Get("yUHNUjEs7rQ");
              //Video v = request.Retrieve<Video>(videoEntryUrl);

              //Feed<Comment> comments = request.GetComments(v);

              //string cm = "";
              //foreach (Comment c in comments.Entries)
              //{
              //  cm += c.Author + c.Content + "------------------------------------------";
              //}
        }

        protected void addVideos(YouTubeFeed videos, YouTubeQuery qu)
        {
            downloaQueue.Clear();
              foreach (YouTubeEntry entry in videos.Entries)
              {
            GUIListItem item = new GUIListItem();
            // and add station name & bitrate
            item.Label = entry.Title.Text; //ae.Entry.Author.Name + " - " + ae.Entry.Title.Content;
            item.Label2 = "";
            item.IsFolder = false;

            try
            {
              item.Duration = Convert.ToInt32(entry.Duration.Seconds, 10);
              if (entry.Rating != null)
            item.Rating = (float)entry.Rating.Average;
            }
            catch
            {

            }

            string imageFile = Youtube2MP.GetLocalImageFileName(GetBestUrl(entry.Media.Thumbnails));
            if (File.Exists(imageFile))
            {
              item.ThumbnailImage = imageFile;
              item.IconImage = imageFile;
              item.IconImageBig = imageFile;
            }
            else
            {
              MediaPortal.Util.Utils.SetDefaultIcons(item);
              item.OnRetrieveArt += item_OnRetrieveArt;
              DownloadImage(GetBestUrl(entry.Media.Thumbnails), item);
              //DownloadImage(GetBestUrl(entry.Media.Thumbnails), item);
            }
            item.MusicTag = entry;
            relatated.Add(item);
              }
              //OnDownloadTimedEvent(null, null);
        }

        private static string YoutubeOutput(string input, string flag)
        {
            YouTubeRequestSettings settings = new YouTubeRequestSettings("Botler", "AI39si4qO-ubkSyRTofnQsaho8bd2vsIXUd8UI874MI6_ulO6gIyR32tUSQJlok__4H0SoaQ5es7Fl1k6P4fuddYn5zdDjzSvw");
            YouTubeRequest request = new YouTubeRequest(settings);
            YouTubeQuery query = new YouTubeQuery(YouTubeQuery.DefaultVideoUri);

            if (flag == "+v")
                query.OrderBy = "viewCount";
            else if (flag == "+r")
                query.OrderBy = "rating";
            else if (flag == "+p")
                query.OrderBy = "published";
            else
                query.OrderBy = "relevance";
            query.Query = input;
            query.SafeSearch = YouTubeQuery.SafeSearchValues.None;
            Feed<Video> videoFeed = request.Get<Video>(query);

            string output = printVideoFeed(videoFeed);
            return output;
        }