use anyhow::{anyhow, bail, Context, Result};
use async_std::task;
use chrono::DateTime;
use sqlx::postgres::PgPoolOptions;
use telegram_bot::{
	_base::Error as TgrError,
	Error as TgError,
use teloxide::{
	Bot,
	payloads::SendMessage,
	requests::Requester,
	types::{
		Me,
		UserId,
	},
};
use thiserror::Error;

use std::{
	borrow::Cow,
	collections::{
		BTreeMap,
		HashSet,
	},
	num::TryFromIntError,
	sync::{
		Arc,
		Mutex
	},
};

#[derive(Error, Debug)]
pub enum RssError {
	#[error(transparent)]
	Tg(#[from] TgError),
	// #[error(transparent)]
	// Tg(#[from] TgError),
	#[error(transparent)]
	Int(#[from] TryFromIntError),
}

#[derive(Clone)]
pub struct Core {
	owner_chat: telegram_bot::UserId,
	pub tg: telegram_bot::Api,
	pub my: telegram_bot::User,
	owner_chat: UserId,
	pub tg: Bot,
	pub my: Me,
	pool: sqlx::Pool<sqlx::Postgres>,
	sources: Arc<Mutex<HashSet<Arc<i32>>>>,
	http_client: reqwest::Client,
}

impl Core {
	pub fn new(settings: config::Config) -> Result<Arc<Core>> {
		let owner = settings.get_int("owner")?;
		let owner: u64 = settings.get_int("owner")?.try_into()?;
		let api_key = settings.get_string("api_key")?;
		let tg = telegram_bot::Api::new(api_key);
		let tg = Bot::new(api_key);
		let tg_cloned = tg.clone();

		let mut client = reqwest::Client::builder();
		if let Ok(proxy) = settings.get_string("proxy") {
			let proxy = reqwest::Proxy::all(proxy)?;
			client = client.proxy(proxy);
		}
		let http_client = client.build()?;
		let core = Arc::new(Core {
			tg,
			my: task::block_on(async {
				tg_cloned.send(telegram_bot::GetMe).await
				tg_cloned.get_me().await
			})?,
			owner_chat: telegram_bot::UserId::new(owner),
			owner_chat: UserId(owner),
			pool: PgPoolOptions::new()
				.max_connections(5)
				.acquire_timeout(std::time::Duration::new(300, 0))
				.idle_timeout(std::time::Duration::new(60, 0))
				.connect_lazy(&settings.get_string("pg")?)?,
			sources: Arc::new(Mutex::new(HashSet::new())),
			http_client,
		});
		let clone = core.clone();
		/* let clone = core.clone();
		task::spawn(async move {
			loop {
				let delay = match &clone.autofetch().await {
					Err(err) => {
						if let Err(err) = clone.send(format!("🛑 {:?}", err), None, None).await {
							eprintln!("Autofetch error: {}", err);
						};
						std::time::Duration::from_secs(60)
					},
					Ok(time) => *time,
				};
				task::sleep(delay).await;
			}
		});
		}); */
		Ok(core)
	}

	pub fn stream(&self) -> telegram_bot::UpdatesStream {
		self.tg.stream()
	pub fn stream(&self) -> Result<()> {
		let mut last_update: Option<i32> = None;
		loop {
			let updates = self.tg.get_updates(last_update, None, 300, Some(vec!["message"]));
		}
		Ok(())
	}

	/*
	pub async fn send<'a, S>(&self, msg: S, target: Option<telegram_bot::UserId>, mode: Option<telegram_bot::types::ParseMode>) -> Result<()>
	where S: Into<Cow<'a, str>> {
		let mode = mode.unwrap_or(telegram_bot::types::ParseMode::Html);
		let target = target.unwrap_or(self.owner_chat);
		self.request(telegram_bot::SendMessage::new(target, msg).parse_mode(mode)).await?;
		Ok(())
	}
	} */

	pub async fn request<Req: telegram_bot::Request> (&self, req: Req) -> Result<<Req::Response as telegram_bot::ResponseType>::Type, RssError> {
	/* pub async fn request<Req: telegram_bot::Request> (&self, req: Req) -> Result<<Req::Response as telegram_bot::ResponseType>::Type, RssError> {
		loop {
			let res = self.tg.send(&req).await;
			match res {
				Ok(_) => return Ok(res?),
				Err(err) => {
					match &err {
						TgError::Raw(TgrError::TelegramError { description: _, parameters: Some(params) }) => {
							if let Some(delay) = params.retry_after {
								println!("Throttled, waiting {} senconds.", delay);
								task::sleep(std::time::Duration::from_secs(delay.try_into()?)).await;
							} else {
								return Err(err.into());
							}
						},
						_ => return Err(err.into()),
					}
				},
			};
		}
	}
	} */

	pub async fn check<S>(&self, id: &i32, owner: S, real: bool) -> Result<Cow<'_, str>>
	/* pub async fn check<S>(&self, id: &i32, owner: S, real: bool) -> Result<Cow<'_, str>>
	where S: Into<i64> {
		let owner = owner.into();
		let mut posted: i32 = 0;
		let mut conn = self.pool.acquire().await?;

		let id = {
			let mut set = self.sources.lock().unwrap();

				posted += 1;
			};
			posts.clear();
		};
		sqlx::query!("update rsstg_source set last_scrape = now() where source_id = $1;",
			*id).execute(&mut *conn).await?;
		Ok(format!("Posted: {}", &posted).into())
	}
	} */

	pub async fn delete<S>(&self, source_id: &i32, owner: S) -> Result<Cow<'_, str>>
	/* pub async fn delete<S>(&self, source_id: &i32, owner: S) -> Result<Cow<'_, str>>
	where S: Into<i64> {
		let owner = owner.into();

		match sqlx::query!("delete from rsstg_source where source_id = $1 and owner = $2;",
			source_id, owner).execute(&mut *self.pool.acquire().await?).await?.rows_affected() {
			0 => { Ok("No data found found.".into()) },
			x => { Ok(format!("{} sources removed.", x).into()) },
		}
	}
	} */

	pub async fn clean<S>(&self, source_id: &i32, owner: S) -> Result<Cow<'_, str>>
	/* pub async fn clean<S>(&self, source_id: &i32, owner: S) -> Result<Cow<'_, str>>
	where S: Into<i64> {
		let owner = owner.into();

		match sqlx::query!("delete from rsstg_post p using rsstg_source s where p.source_id = $1 and owner = $2 and p.source_id = s.source_id;",
			source_id, owner).execute(&mut *self.pool.acquire().await?).await?.rows_affected() {
			0 => { Ok("No data found found.".into()) },
			x => { Ok(format!("{} posts purged.", x).into()) },
		}
	}
	} */

	pub async fn enable<S>(&self, source_id: &i32, owner: S) -> Result<&str>
	/* pub async fn enable<S>(&self, source_id: &i32, owner: S) -> Result<&str>
	where S: Into<i64> {
		let owner = owner.into();

		match sqlx::query!("update rsstg_source set enabled = true where source_id = $1 and owner = $2",
			source_id, owner).execute(&mut *self.pool.acquire().await?).await?.rows_affected() {
			1 => { Ok("Source enabled.") },
			0 => { Ok("Source not found.") },
			_ => { Err(anyhow!("Database error.")) },
		}
	}
	} */

	pub async fn disable<S>(&self, source_id: &i32, owner: S) -> Result<&str>
	/* pub async fn disable<S>(&self, source_id: &i32, owner: S) -> Result<&str>
	where S: Into<i64> {
		let owner = owner.into();

		match sqlx::query!("update rsstg_source set enabled = false where source_id = $1 and owner = $2",
			source_id, owner).execute(&mut *self.pool.acquire().await?).await?.rows_affected() {
			1 => { Ok("Source disabled.") },
			0 => { Ok("Source not found.") },
			_ => { Err(anyhow!("Database error.")) },
		}
	}
	} */

	pub async fn update<S>(&self, update: Option<i32>, channel: &str, channel_id: i64, url: &str, iv_hash: Option<&str>, url_re: Option<&str>, owner: S) -> Result<&str>
	/* pub async fn update<S>(&self, update: Option<i32>, channel: &str, channel_id: i64, url: &str, iv_hash: Option<&str>, url_re: Option<&str>, owner: S) -> Result<&str>
	where S: Into<i64> {
		let owner = owner.into();
		let mut conn = self.pool.acquire().await?;

		match match update {
				Some(id) => {
					sqlx::query!("update rsstg_source set channel_id = $2, url = $3, iv_hash = $4, owner = $5, channel = $6, url_re = $7 where source_id = $1",

				reply.push(format!("IV: `{}`", hash).into());
			}
			if let Some(re) = &row.url_re {
				reply.push(format!("RE: `{}`", re).into());
			}
		};
		Ok(reply.join("\n"))
	}
	} */
}