//! Simple SMTP-to-Telegram gateway. Can parse email and send them as telegram
//! messages to specified chats, generally you specify which email address is
//! available in configuration, everything else is sent to default address.

use anyhow::Result;
use async_std::{
	fs::metadata,
	io::Error,
	task,
};
use frankenstein::{
	client_reqwest::Bot,
	input_file::InputFile,
	input_media::{InputMedia, InputMediaDocument},
	methods::{SendDocumentParams, SendMessageParams},
	response::MethodResponse,
	types::{
		ChatId,
		Message,
	},
	AsyncTelegramApi,
	ParseMode::MarkdownV2,
};
use just_getopt::{
	OptFlags,
	OptSpecs,
	OptValueType,
};
use lazy_static::lazy_static;
use mailin_embedded::{
	Response,
	response::*,
};
use regex::Regex;













use thiserror::Error;

use std::{
	borrow::Cow,
	collections::{
		HashMap,
		HashSet,

	#[error("No headers found")]
	NoHeaders,
	#[error("No recipient addresses")]
	NoRecipient,
	#[error("Failed to extract text from message")]
	NoText,
	#[error(transparent)]
	RequestError(#[from] frankenstein::Error),
}

/// `SomeHeaders` object to store data through SMTP session
#[derive(Clone, Debug)]
struct SomeHeaders {
	from: String,
	to: Vec<String>,
}

/// `TelegramTransport` Central object with TG api and configuration
#[derive(Clone)]
struct TelegramTransport {
	data: Vec<u8>,
	headers: Option<SomeHeaders>,
	recipients: HashMap<String, ChatId>,
	relay: bool,
	tg: Bot,
	fields: HashSet<String>,
}

lazy_static! {
	static ref RE_SPECIAL: Regex = Regex::new(r"([\-_*\[\]()~`>#+|{}\.!])").unwrap();
}

		assert_eq!(res, "\\-\\_\\*\\[\\]\\(\\)\\~\\`\\>\\#\\+\\|\\{\\}\\.\\!");
	}
}

impl TelegramTransport {
	/// Initialize API and read configuration
	fn new(settings: config::Config) -> TelegramTransport {
		let tg = Bot::new(&settings.get_string("api_key")
			.expect("[smtp2tg.toml] missing \"api_key\" parameter.\n"));


		let recipients: HashMap<String, ChatId> = settings.get_table("recipients")
			.expect("[smtp2tg.toml] missing table \"recipients\".\n")
			.into_iter().map(|(a, b)| (a, b.into_int()
				.expect("[smtp2tg.toml] \"recipient\" table values should be integers.\n").into()
				)).collect();
		if !recipients.contains_key("_") {
			eprintln!("[smtp2tg.toml] \"recipient\" table misses \"default_recipient\".\n");
			panic!("no default recipient");
		}
		let fields = HashSet::<String>::from_iter(settings.get_array("fields")
			.expect("[smtp2tg.toml] \"fields\" should be an array")
			.iter().map(|x| x.clone().into_string().expect("should be strings")));

			relay,
			tg,
			fields,
		}
	}

	/// Send message to default user, used for debug/log/info purposes
	async fn debug (&self, msg: &str) -> Result<MethodResponse<Message>, MyError> {
		let msg = SendMessageParams::builder()
			.chat_id(self.recipients.get("_").ok_or(MyError::NoDefault)?.clone())
			.text(encode(msg))
			.build();
		Ok(self.tg.send_message(&msg).await?)
	}

	/// Send message to specified user
	async fn send <S> (&self, to: &ChatId, msg: S) -> Result<MethodResponse<Message>, MyError>
	where S: Into<String> {
		let msg = SendMessageParams::builder()
			.chat_id(to.clone())
			.text(msg)
			.build();
		Ok(self.tg.send_message(&msg).await?)
	}

	/// Attempt to deliver one message
	async fn relay_mail (&self) -> Result<(), MyError> {
		if let Some(headers) = &self.headers {
			let mail = mail_parser::MessageParser::new().parse(&self.data)
				.ok_or(MyError::BadMail)?;

							fname
						} else {
							"Attachment.txt".into()
						};
						let item = teloxide::types::InputMediaDocument::new(
							teloxide::types::InputFile::memory(data.to_vec())
							.file_name(filename));
						let item = InputMediaDocument::builder()
							.media(data)
							.build();
						let item = if first_one {
							first_one = false;
							item.caption(&msg)
						} else {
							item
						};
						files.push(InputMedia::Document(item));