// Copyright (C) 2023-2099 The crate authors.
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Affero General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
// for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

#![feature(let_chains)]
#![feature(never_type)]

mod bot;
mod error;
mod web;
mod webhook;

use crate::bot::XmppClient;
use crate::error::Error;
use crate::web::webhooks;
use crate::webhook::Hook;

use std::fs::File;
use std::io::{Error as IoError, ErrorKind as IoErrorKind, Read};
use std::net::{IpAddr, Ipv6Addr, SocketAddr};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

use clap::{command, value_parser, Arg};
use hyper::{server::conn::http1, service::service_fn};
use hyper_util::rt::tokio::{TokioIo, TokioTimer};
use log::debug;
use serde::{Deserialize, Serialize};
use tokio::{net::TcpListener, sync::mpsc};
use xmpp::BareJid;

#[derive(Debug, Serialize, Deserialize)]
struct Config {
	/// Account address
	jid: BareJid,

	/// Account password
	password: String,

	/// Rooms to join, e.g., room@chat.example.org
	#[serde(default = "Vec::new")]
	rooms: Vec<BareJid>,

	/// Nickname to use in rooms
	#[serde(default = "default_nickname")]
	nickname: String,

	/// Token to match the one provided by the Webhook service
	#[serde(rename = "webhook-token")]
	webhook_token: String,

	/// HTTP Webhook listening address and port, e.g., 127.0.0.1:1234 or [::1]:1234
	#[serde(default = "default_addr")]
	addr: SocketAddr,
}

fn default_nickname() -> String {
	String::from("cusku")
}

fn default_addr() -> SocketAddr {
	SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 3000)
}

fn config_from_file(file: PathBuf) -> Result<Config, Error> {
	if file.try_exists().is_err() {
		let err = IoError::new(IoErrorKind::NotFound, format!("{:?} not found", file));
		return Err(Error::Io(err));
	}

	let mut buf = String::new();
	let mut f = File::open(file)?;
	f.read_to_string(&mut buf)?;

	Ok(toml::from_str(&buf)?)
}

#[tokio::main]
async fn main() -> Result<!, Error> {
	pretty_env_logger::init();

	let matches = command!()
		.arg(
			Arg::new("config")
				.short('c')
				.long("config")
				.required(false)
				.value_parser(value_parser!(PathBuf)),
		)
		.get_matches();

	let config = {
		let path = match matches.get_one::<PathBuf>("config") {
			Some(path) => {
				if !path.starts_with("/") {
					std::env::current_dir()?.join(path)
				} else {
					path.to_path_buf()
				}
			}
			None => {
				let confdir: PathBuf = match std::env::var("XDG_CONFIG_HOME") {
					Ok(ref dir) => Path::new(dir).to_path_buf(),
					Err(_) => {
						let home = std::env::var("HOME")?;
						Path::new(home.as_str()).join(".config")
					}
				};

				confdir.join("cusku/config.toml")
			}
		};

		debug!("Using configuration file: {:?}", path);

		match config_from_file(path) {
			Ok(config) => config,
			Err(err) => return Err(err),
		}
	};

	let (value_tx, mut value_rx) = mpsc::unbounded_channel::<Hook>();

	let mut client = XmppClient::new(
		config.jid,
		config.password.as_str(),
		config.rooms,
		config.nickname,
	);

	let tcp_bind = TcpListener::bind(config.addr).await?;
	let token: &'static String =
		unsafe { core::mem::transmute::<&String, &'static String>(&config.webhook_token) };
	let value_tx = Arc::new(Mutex::new(value_tx));

	loop {
		let value_tx = value_tx.clone();

		tokio::select! {
			_ = client.next() => (),
			accept = tcp_bind.accept() => {
				if let Ok((tcp, _)) = accept {
					let io = TokioIo::new(tcp);
					tokio::task::spawn(async move {
						if let Err(err) = http1::Builder::new()
							.timer(TokioTimer::new())
							.serve_connection(io, service_fn(|request| {
								let value_tx = value_tx.clone();
								async move {
									webhooks(request, token, value_tx).await
								}
							}))
							.await
						{
							println!("Error serving connection: {:?}", err);
						}
					});
				}
			}
			wh = value_rx.recv() => {
				if let Some(Hook::Gitlab(hook)) = wh {
					client.webhook(hook).await
				}
			}
		}
	}
}