/** Lists the user's blogs and returns the URI for posting new entries
         * to the blog which the user selected.
         */
        static Uri SelectUserBlog(Service service)
        {
            Console.WriteLine("\nPlease select a blog on which to post.");
            FeedQuery query = new FeedQuery();
            // Retrieving a list of blogs
            query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
            AtomFeed feed = service.Query(query);

            // Publishing a blog post
            Uri blogPostUri = null;
            if (feed != null)
            {
                foreach (AtomEntry entry in feed.Entries)
                {
                    // Print out the title of the Blog
                    Console.WriteLine("  Blog name: " + entry.Title.Text);
                    Console.Write("  Post to this blog? (y/n): ");
                    if (Console.ReadLine().Equals("y"))
                    {
                        // find the href in the link with a rel pointing to the blog's feed
                        for (int i = 0; i < entry.Links.Count; i++)
                        {
                            if (entry.Links[i].Rel.Equals("http://schemas.google.com/g/2005#post"))
                            {
                                blogPostUri = new Uri(entry.Links[i].HRef.ToString());
                                Console.WriteLine("  Your new posts will be sent to " + blogPostUri.AbsoluteUri.ToString());
                            }
                        }
                        return blogPostUri;
                    }
                }
            }
            return blogPostUri;
        }

        internal CellFeed fetch(string uri)
        {
            try {
                // フィードアドレス設定
                FeedQuery singleQuery = new FeedQuery();
                singleQuery.Uri = new Uri(uri);

                AtomFeed feed;
                SpreadsheetEntry spreadsheet;

                // フィード取得
                feed = service.Query(singleQuery); // 認証エラーはここから
                if (feed.Entries.Count == 0) {
                    return null;
                }
                spreadsheet = (SpreadsheetEntry)feed.Entries[0];
                WorksheetFeed wsFeed = spreadsheet.Worksheets;
                WorksheetEntry worksheet = (WorksheetEntry)wsFeed.Entries[0];
                // Fetch the cell feed of the worksheet.
                CellQuery cellQuery = new CellQuery(worksheet.CellFeedLink);
                cellQuery.MinimumRow = 3;
                cellQuery.MinimumColumn = 2;
                cellQuery.MaximumColumn = 4;

                return service.Query(cellQuery);

            } catch (InvalidCredentialsException) {
                // 認証エラー
                throw;
            } catch (GDataRequestException) {
                // Execution of request failed: {address}
                throw;
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Suchwort:");
            string searchTerm = Console.ReadLine();

            string uriSearchTerm = HttpUtility.UrlEncode(searchTerm);
            string url = "http://gdata.youtube.com/feeds/videos?q=" + uriSearchTerm;
            
            Console.WriteLine("Connection to YouTube - Searching: " + searchTerm);

            FeedQuery query = new FeedQuery("");
            Service service = new Service("youtube", "sample");
            query.Uri = new Uri(url);
            query.StartIndex = 0;
            query.NumberToRetrieve = 20;
            AtomFeed resultFeed = service.Query(query);

            foreach (AtomEntry entry in resultFeed.Entries)
            {
                Console.WriteLine("Title: " + entry.Title.Text);
                Console.WriteLine("Link: " + entry.AlternateUri.Content);
                Console.WriteLine("Tags:");
                foreach (AtomCategory cat in entry.Categories)
                {
                    Console.Write(cat.Term + ", ");
                }
                Console.WriteLine();
            }

            Console.ReadLine();
        }

        public IList<BlogEntry> GetAllEntries()
        {
            FeedQuery query = new FeedQuery();
            query.Uri = new Uri("http://www.blogger.com/feeds/" + BlogId + "/posts/default");
            query.NumberToRetrieve = 500;

            return MapEntries(Service.Query(query).Entries);
        }

 /// <summary>
 ///  overwritten Query method
 /// </summary>
 /// <param name="feedQuery">The CodeSearchQuery touse</param>
 /// <returns>the retrieved CodeSearchFeed</returns>
 public new CodeSearchFeed Query(FeedQuery feedQuery) 
 {
     Stream feedStream = Query(feedQuery.Uri);
     CodeSearchFeed feed = new CodeSearchFeed(feedQuery.Uri, this);
     feed.Parse(feedStream, AlternativeFormat.Atom);
     feedStream.Close(); 
     return feed;
 }

        public AtomFeed GetGoogleCalendar()
        {
            Service service = new Service();
            FeedQuery query = new FeedQuery();
            query.Uri = new Uri(publicCalendarUrl);
            return service.Query(query);

        }

 public void UseSSLTest()
 {
     FeedQuery target = new FeedQuery(); // TODO: Initialize to an appropriate value
     bool expected = true; 
     bool actual;
     target.UseSSL = expected;
     actual = target.UseSSL;
     Assert.AreEqual(expected, actual);
 }

        //////////////////////////////////////////////////////////////////////
        /// <summary>empty a feed</summary> 
        //////////////////////////////////////////////////////////////////////
        protected void FeedCleanup(String uriToClean, String userName, String pwd)
        {
            Tracing.TraceCall();
            Tracing.TraceCall("Cleaning URI: " + uriToClean);

            if (!this.wipeFeeds)
            {
                Tracing.TraceInfo("Skipped cleaning URI due to configuration.");
                return;
            }

            FeedQuery query = new FeedQuery();
            Service service = new Service();

            if (uriToClean != null)
            {
                if (userName != null)
                {
                    service.Credentials = new GDataCredentials(userName, pwd);
                }

                GDataLoggingRequestFactory factory = (GDataLoggingRequestFactory)this.factory;
                factory.MethodOverride = true;
                service.RequestFactory = this.factory; 

                query.Uri = new Uri(uriToClean);

                Tracing.TraceCall("Querying " + uriToClean);
                AtomFeed feed = service.Query(query);
                Tracing.TraceCall("Queryed " + uriToClean);
                if (feed != null)
                    Tracing.TraceCall("Entries: " + feed.Entries.Count.ToString());

                int iCount = 0; 

                if (feed.Entries.Count > 0)
                {
                    while (feed.Entries.Count > 0)
                    {
                        Tracing.TraceCall("Feed has still " + feed.Entries.Count.ToString() + " entries left.");
                        foreach (AtomEntry entry in feed.Entries)
                        {
                            Tracing.TraceCall("Deleting entry " + iCount);
                            entry.Delete();
                            iCount++; 
                            Tracing.TraceCall("Deleted entry " + iCount);
                        }
                        feed = service.Query(query);
                    }

                    Assert.AreEqual(0, feed.Entries.Count, "Feed should have no more entries, it has: " + feed.Entries.Count); 
                    service.Credentials = null; 
                    factory.MethodOverride = false;
                }
            }
        }

        /////////////////////////////////////////////////////////////////////////////



        //////////////////////////////////////////////////////////////////////
        /// <summary>[Test] creates a new entry, saves and loads it back</summary> 
        //////////////////////////////////////////////////////////////////////
        [Test] public void DefaultHostInsertOneAndDelete()
        {
            Tracing.TraceMsg("Entering DefaultHostInsertOneAndDelete");
            AtomEntry entry = ObjectModelHelper.CreateAtomEntry(1); 
            Service service = new Service();
            FeedQuery query = new FeedQuery();
            service.RequestFactory = this.factory; 

            int iCount=0; 

            string strTitle = "DefaultHostInsertOneAndDelete" + Guid.NewGuid().ToString(); 
            entry.Title.Text = strTitle; 

            query.Uri = new Uri(this.defaultHost);
            AtomFeed returnFeed = service.Query(query);

            iCount = returnFeed.Entries.Count; 


            for (int i = 0; i < this.iIterations; i++)
            {
                Tracing.TraceMsg("DefaultHostInsertOneAndDelete, iteration : " + i); 

                Stream s = service.EntrySend(new Uri(this.defaultHost), entry, GDataRequestType.Insert); 
                s.Close();

                returnFeed = service.Query(query);
                Assert.AreEqual(iCount+1, returnFeed.Entries.Count, "feed should have one more entry now"); 

                AtomEntry returnEntry = null;

                foreach (AtomEntry feedEntry in returnFeed.Entries )
                {
                    if (String.Compare(feedEntry.Title.Text, strTitle) == 0)
                    {
                        // got him
                        returnEntry = feedEntry; 
                        break;
                    }
                }

                Assert.IsTrue(returnEntry != null, "did not find the just inserted entry"); 

                returnEntry.Delete();

                // query again and check count

                returnFeed = service.Query(query);

                Assert.AreEqual(iCount, returnFeed.Entries.Count, "feed has different number of entries as expected"); 
            }
        }

 /** Lists the user's blogs. */
 static void ListUserBlogs(Service service)
 {
     Console.WriteLine("\nRetrieving a list of blogs");
     FeedQuery query = new FeedQuery();
     // Retrieving a list of blogs
     query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
     AtomFeed feed = null;
     feed = service.Query(query);
     foreach (AtomEntry entry in feed.Entries)
     {
         Console.WriteLine("  Blog title: " + entry.Title.Text);
     }
 }

        public ActionResult IndexOLD(string id)
        {
            string uri;
            bool permalink = false;
            if (string.IsNullOrEmpty(id))
                uri = _baseUri;
            else
            {
                uri = postUri(id);
                permalink = true;
            }

            FeedQuery query = new FeedQuery();
            query.Uri = new Uri(uri);

            if (!permalink)
            {
                query.StartIndex = 0;
                query.NumberToRetrieve = 2;
            }

            AtomFeed feed = null;
            feed = _service.Query(query);

            var bpl = new List<BlogPost>();

            foreach (var e in feed.Entries)
            {
                var bp = new BlogPost()
                    {
                        Title = e.Title.Text,
                        Content = e.Content.Content,
                        Date = e.Published,
                        ID = e.EditUri.Content.Substring(e.EditUri.Content.LastIndexOf('/') + 1)
                    };
                bpl.Add(bp);
            }

            return View(new BlogListData()
                {
                    //SideBarData = new Models.Shared.MainSideBarData(),
                    Posts = bpl
                    //Posts = feed.Entries.Select(e => new BlogPost()
                    //{
                    //    Title = e.Title.Text,
                    //    Content = e.Content.Content,
                    //    Date = e.Published,
                    //    ID = Regex.Replace(e.Links.Single(l => l.Rel == "edit").HRef.ToString(), uri + "/", "")
                    //}).ToList()
                });
        }

        private IList<Webinar> LoadWebinars()
        {
            var service = new YouTubeService("HibernatingRhinosExercise");
            var query = new FeedQuery(_uri);
            var webinars = new List<Webinar>();

            AtomFeed result = service.Query(query);
            if (result != null)
            {
                webinars = ParseAtomFeed(result);
            }

            return webinars;
        }

        public IList<Webinar> FindWebinars(string keyword)
        {
            var service = new YouTubeService("HibernatingRhinosExercise");
            var query = new FeedQuery("https://gdata.youtube.com/feeds/api/videos?q={0}" + keyword);
            var webinars = new List<Webinar>();

            AtomFeed result = service.Query(query);
            if (result != null)
            {
                webinars = ParseAtomFeed(result);
            }

            return webinars;
        }

        public void getActivityFeed(String feedUri)
        {
            FeedQuery query = new FeedQuery();
            query.Uri = new Uri(feedUri);
            AtomFeed feed = service.Query(query);

            foreach (AtomEntry entry in feed.Entries)
            {
                Console.WriteLine(String.Format("Page: {0}", entry.Title.Text));

                String actionType = getCategoryLabel(entry.Categories);
                Console.WriteLine(String.Format("  {0} on {1}, by {2}", actionType,
                    entry.Updated.ToShortDateString(), entry.Authors[0].Email));
            }
        }

        public static AtomFeed GetFeed(string url = "", int start = 0, int num_results = 0)
        {
            FeedQuery query = new FeedQuery("");
            Google.GData.Client.Service service = new Google.GData.Client.Service();
            query.Uri = new Uri(url);
            if (start > 0) {
                query.StartIndex = start;
            }
            if (num_results > 0) {
                query.NumberToRetrieve = num_results;
            }

            AtomFeed feed = service.Query(query);
            return feed;
        }

        //////////////////////////////////////////////////////////////////////
        /// <summary>[Test] public QueryObjectTest()</summary> 
        //////////////////////////////////////////////////////////////////////
        [Test] public void QueryObjectTest()
        {
            Tracing.TraceInfo("Entering QueryObject Test"); 

            FeedQuery query = new FeedQuery();
            query.Uri = new Uri(this.defaultHost);

            AtomCategory aCat = new AtomCategory("Test", new AtomUri("urn:test.com")); 
            QueryCategory qCat = new QueryCategory(aCat);
            query.Categories.Add(qCat);

            aCat = new AtomCategory("TestNotAndOr", new AtomUri("urn:test.com")); 
            qCat = new QueryCategory(aCat);
            qCat.Operator = QueryCategoryOperator.OR; 
            qCat.Excluded = true; 

            query.Categories.Add(qCat);


            aCat = new AtomCategory("ANDTHISONE", new AtomUri("")); 
            qCat = new QueryCategory(aCat);
            query.Categories.Add(qCat);

            aCat = new AtomCategory("AnotherOrWithoutCategory"); 
            qCat = new QueryCategory(aCat);
            qCat.Operator = QueryCategoryOperator.OR; 
            qCat.Excluded = true; 
            query.Categories.Add(qCat);

            query.Query = "Hospital";
            query.NumberToRetrieve = 20; 
            Tracing.TraceInfo("query: "  + query.Uri);  

            Uri uri =  query.Uri; 
            Tracing.TraceInfo("Uri: query= " + uri.Query); 
            query.Uri = uri; 
            Tracing.TraceInfo("Parsed Query URI: " + query.Uri); 
            Assert.IsTrue(uri.AbsolutePath.Equals(query.Uri.AbsolutePath), "both query URIs should be identical, uri: " + uri.AbsolutePath + " compared to query: " + query.Uri.AbsolutePath); 

            query.CategoryQueriesAsParameter = true;

            uri = query.Uri;
            Tracing.TraceInfo("Uri: query= " + uri.Query); 
            query.Uri = uri; 
            Tracing.TraceInfo("Parsed Query URI: " + query.Uri.AbsoluteUri); 
            Assert.IsTrue(uri.AbsolutePath.Equals(query.Uri.AbsolutePath), "both query URIs should be identical, uri: " + uri.AbsolutePath + " compared to query: " + query.Uri.AbsolutePath); 

        }

        /// <summary>
        /// Prints a list of the user's calendars.
        /// </summary>
        /// <param name="service">The authenticated CalendarService object.</param>
        static void PrintUserCalendars(CalendarService service)
        {
            FeedQuery query = new FeedQuery();
            query.Uri = new Uri("http://www.google.com/calendar/feeds/default");

            // Tell the service to query:
            AtomFeed calFeed = service.Query(query);

            Console.WriteLine("Your calendars:");
            Console.WriteLine();
            for (int i = 0; i < calFeed.Entries.Count; i++)
            {
                Console.WriteLine(calFeed.Entries[i].Title.Text);
            }
            Console.WriteLine();
        }

        //////////////////////////////////////////////////////////////////////
        /// <summary>deletes all entries in defhost feed</summary> 
        //////////////////////////////////////////////////////////////////////
        [Test] public void DefaultHostDeleteAll()
        {
            Tracing.TraceMsg("Entering DefaultHostDeleteAll");

            FeedQuery query = new FeedQuery();
            Service service = new Service();
            service.RequestFactory = this.factory; 
            query.Uri = new Uri(this.defaultHost);

            AtomFeed returnFeed = service.Query(query);

            foreach (AtomEntry entry in returnFeed.Entries )
            {
                entry.Delete();
            }
        }

        public GoogleFinanceLib()
        {
            Service sFinance = new Service("finance", "StockTicker");//"CCSC-StockTicker-1a");

            /*
             *  Setup credentials.
             */
            sFinance.Credentials = new GDataCredentials(sUsername, sPassword);
            GDataGAuthRequestFactory rfFactory = (GDataGAuthRequestFactory)sFinance.RequestFactory;
            rfFactory.AccountType = "GOOGLE";

            FeedQuery fqQuery = new FeedQuery();
            /*
             *  Need "query" uri.
             */
            fqQuery.Uri = new Uri("http://www.google.com/finance");
            fqQuery.Query = "GOOG";
            /*            AtomFeed afFeed = sFinance.Query(fqQuery);
            */
            //            string s = "";
        }

        public List<Calendar> GetUserCalendars()
        {
            FeedQuery query = new FeedQuery();
            query.Uri = new Uri(GoogleFeedsUriDefault);

            // Tell the service to query:
            AtomFeed calFeed = calendarService.Query(query);

            List<Calendar> result = new List<Calendar>();
            foreach (var item in calFeed.Entries)
            {
                var calID = item.SelfUri.ToString().Split(new char[] {'/'});
                var calendar = new Calendar
                {
                    Title = item.Title.Text,
                    CalendarID = calID.Last()
                };
                result.Add(calendar);
            }

            return result;
        }