use std::collections::{BTreeMap, HashSet};
use std::sync::{Arc, Mutex};

use chrono::DateTime;
use config;

use tokio;
use futures::StreamExt;
use regex::Regex;
use reqwest;
use sqlx::postgres::PgPoolOptions;
use sqlx::Row;
use tokio;

use rss;
use atom_syndication;

use chrono::DateTime;

use regex::Regex;

use telegram_bot::*;
use tokio::stream::StreamExt;
//use tokio::stream::StreamExt;

use sqlx::postgres::PgPoolOptions;
use sqlx::Row;

#[macro_use]
extern crate lazy_static;

use anyhow::{anyhow, bail, Context, Result};

#[derive(Clone)]

					sqlx::query("insert into rsstg_post (source_id, posted, url) values ($1, $2, $3);")
						.bind(*id)
						.bind(date)
						.bind(url)
						.execute(&mut conn).await
						.with_context(|| format!("Record post:\n{:?}", &conn))?;
					drop(conn);
					tokio::time::delay_for(std::time::Duration::new(4, 0)).await;
					tokio::time::sleep(std::time::Duration::new(4, 0)).await;
				};
			};
			posts.clear();
		};
		let mut conn = self.pool.acquire().await
			.with_context(|| format!("Update scrape fetch conn:\n{:?}", &self.pool))?;
		sqlx::query("update rsstg_source set last_scrape = now() where source_id = $1;")

				} else {
					if next_fetch - now < delay {
						delay = next_fetch - now;
					}
				}
			};
			queue.clear();
			tokio::time::delay_for(delay.to_std()?).await;
			tokio::time::sleep(delay.to_std()?).await;
			delay = chrono::Duration::minutes(1);
		}
	}

	async fn list<S>(&self, owner: S) -> Result<Vec<String>>
	where S: Into<i64> {
		let owner = owner.into();