use std::collections::HashSet;
use std::fmt::Display;
use std::path::{Path, PathBuf};
use std::sync::mpsc::{Receiver, Sender};
use std::time::Duration;

use auth_git2::GitAuthenticator;
use chrono::{Local, Utc};
use git_autosave::{Autosave, Config, authenticate::Inquirer, commit_autosave, push_autosaves};
use git2::build::CheckoutBuilder;
use git2::{RemoteCallbacks, Repository, StatusOptions};
use happylock::{Mutex, ThreadKey};
use notify::{EventKind, RecommendedWatcher, RecursiveMode};
use notify_debouncer_full::{DebounceEventHandler, DebounceEventResult, Debouncer, FileIdCache};

const THREE_MONTHS: i64 = 60 * 60 * 24 * 30 * 3;

struct AutosaveOption {
	text: String,
	value: Autosave,
}

impl Display for AutosaveOption {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		self.text.fmt(f)
	}
}

struct ConfigWatcher<Cache: FileIdCache + 'static> {
	config: &'static Mutex<Config>,
	repo_watcher: &'static mut Debouncer<RecommendedWatcher, Cache>,
}

struct RepoWatcher {
	config: &'static Mutex<Config>,
	push_queue: Sender<PathBuf>,
}

fn push_queue(
	consumer: Receiver<PathBuf>,
	config: &'static Mutex<Config>,
	mut key: ThreadKey,
) -> ! {
	let mut queue = HashSet::new();

	loop {
		while ping::new("8.8.8.8".parse().unwrap())
			.socket_type(ping::SocketType::DGRAM)
			.timeout(Duration::from_secs(60))
			.ttl(128)
			.send()
			.is_err()
		{
			let mut added_item = false;
			while let Ok(workdir) = consumer.try_recv() {
				added_item = true;
				queue.insert(workdir);
			}
			if added_item {
				log::warn!(
					"There is no Internet connection, so pushes to the repository have been queued"
				);
			}
			std::thread::yield_now();
		}

		while let Ok(workdir) = consumer.try_recv() {
			queue.insert(workdir);
		}

		config.scoped_lock(&mut key, |config| {
			for workdir in &queue {
				log::info!("Pushing {}...", workdir.to_string_lossy());
				let Ok(repository) = Repository::open(workdir) else {
					log::error!("Failed to open repository: {}", workdir.to_string_lossy());
					continue;
				};
				let Ok(gitconfig) = repository.config() else {
					log::error!("Failed to load gitconfig for repository: {:?}", workdir);
					return;
				};
				let auth = GitAuthenticator::new().set_prompter(Inquirer(&*config));
				let mut callbacks = RemoteCallbacks::new();
				callbacks.credentials(auth.credentials(&gitconfig));
				if let Err(e) = push_autosaves(&repository, callbacks) {
					log::error!("Failed to push autosaves: {e}");
				}

				log::info!("Successfully pushed {}", workdir.to_string_lossy());
			}
		});
		queue.clear();
	}
}

impl<Cache: FileIdCache + Send + 'static> DebounceEventHandler for ConfigWatcher<Cache> {
	fn handle_event(&mut self, events: DebounceEventResult) {
		let events = match events {
			Ok(events) => events,
			Err(errors) => {
				for error in errors {
					log::error!("Failed to load event: {error}");
				}
				return;
			}
		};
		if events
			.iter()
			.all(|event| matches!(event.kind, EventKind::Access(_)))
		{
			return;
		}

		log::info!("The config was updated. Reloading...");
		let Some(key) = ThreadKey::get() else {
			log::error!("Failed to acquire thread key when reloading config. This is a bug!");
			return;
		};
		let config = match Config::load() {
			Ok(config) => config,
			Err(e) => {
				log::error!("Failed to reload autosave config: {e}");
				return;
			}
		};

		self.config.scoped_lock(key, |old_config| {
			let paths_to_unwatch = old_config.repositories().difference(config.repositories());
			let paths_to_watch = config.repositories().difference(old_config.repositories());
			for path in paths_to_unwatch {
				if let Err(e) = self.repo_watcher.unwatch(path) {
					log::error!("Error when removing path from being watched: {e}");
				}
				log::info!("Removed {path:?} from list of repos to watch");
			}
			for path in paths_to_watch {
				if let Err(e) = self.repo_watcher.watch(path, RecursiveMode::Recursive) {
					log::error!("Error when adding path to repositories to watch: {e}");
				}
				log::info!("Added {path:?} from list of repos to watch");
			}

			*old_config = config;
		});

		log::info!("Successfully reloaded autosave config");
	}
}

impl DebounceEventHandler for RepoWatcher {
	fn handle_event(&mut self, events: DebounceEventResult) {
		let Some(mut key) = ThreadKey::get() else {
			log::error!("Failed to acquire thread key when autosaving repository. This is a bug!");
			return;
		};
		let events = match events {
			Ok(events) => events,
			Err(errors) => {
				for error in errors {
					log::error!("Failed to get update events: {error}");
				}
				return;
			}
		};

		let mut workdirs_to_autosave = HashSet::new();
		let mut repositories_to_autosave = Vec::new();
		for (event, path) in events
			.iter()
			.filter(|event| !matches!(event.kind, EventKind::Access(_)))
			.flat_map(|event| event.paths.iter().map(move |path| (event, path)))
		{
			if path
				.components()
				.any(|component| component.as_os_str() == ".git")
			{
				// Prevent infinite loop from commits triggering autosaves
				continue;
			}

			let Ok(repository) = Repository::discover(path) else {
				log::warn!("Skipping non-repository: {:?}", &path);
				continue;
			};
			let Some(workdir) = repository.workdir() else {
				log::warn!("Skipping bare repository: {:?}", &path);
				continue;
			};
			if workdirs_to_autosave.contains(workdir) {
				continue;
			}
			match repository.is_path_ignored(path) {
				Ok(true) => {
					log::trace!("Skipping event for ignored path: {:?}", path);
					continue;
				}
				Ok(false) => {}
				Err(e) => {
					log::error!("Failed to determine if path is ignore: {e}");
				}
			}
			if let Ok(status) = repository.statuses(Some(
				StatusOptions::new()
					.include_untracked(true)
					.include_ignored(false),
			)) && status.is_empty()
			{
				continue;
			}

			log::info!("Event: {:?}", event);
			log::info!("Updated path: {:?}", &path);
			workdirs_to_autosave.insert(workdir.to_path_buf());
			repositories_to_autosave.push(repository);
		}
		self.config.scoped_lock(&mut key, |config| {
			for repository in repositories_to_autosave {
				let workdir = repository
					.workdir()
					.map(|path| path.to_string_lossy())
					.unwrap_or_default();
				log::info!("Autosaving {:?}...", workdir);
				let Ok(gitconfig) = repository.config() else {
					log::error!("Failed to load gitconfig for repository: {:?}", workdir);
					return;
				};
				let auth = GitAuthenticator::new().set_prompter(Inquirer(&*config));
				let mut callbacks = RemoteCallbacks::new();
				callbacks.credentials(auth.credentials(&gitconfig));

				if let Err(e) = commit_autosave(&repository) {
					log::error!("Failed to commit autosave: {e}");
				}
				if let Err(e) = self
					.push_queue
					.send(repository.workdir().unwrap().to_path_buf())
				{
					log::error!("Failed to add repository to push queue: {e}");
				}

				log::info!("Successfully autosaved {:?}", workdir);
			}
		});
	}
}

fn daemon() -> Result<(), anyhow::Error> {
	let mut key = ThreadKey::get().expect("Could not get ThreadKey on startup. This is a bug!");
	colog::init();

	log::info!("Loading autosave config...");
	let config: &'static Mutex<Config> = Box::leak(Box::new(Mutex::new(Config::load()?)));
	log::info!("Loaded autosave config");

	log::info!("Starting push queue...");
	let (sender, receiver) = std::sync::mpsc::channel();
	std::thread::spawn(move || {
		let key = ThreadKey::get().unwrap();
		push_queue(receiver, config, key);
	});
	config.scoped_lock(&mut key, |config| {
		for repository in config.repositories() {
			if let Err(e) = sender.send(repository.clone()) {
				log::error!("Failed to queue {}: {e}", repository.to_string_lossy());
			}
		}
	});
	log::info!("Started push queue");

	log::info!("Starting repository watcher...");
	let repo_watcher = Box::leak(Box::new(notify_debouncer_full::new_debouncer(
		Duration::from_secs(5),
		None,
		RepoWatcher {
			config,
			push_queue: sender,
		},
	)?));
	config.scoped_lock(key, |config| {
		log::info!("Adding repositories to watch...");
		for repository in config.repositories() {
			if let Err(e) = repo_watcher.watch(repository, RecursiveMode::Recursive) {
				log::error!("Failed to watch {repository:?}: {e}");
			}
			log::info!("Added {repository:?}");
		}
	});
	log::info!("Started repository watcher");
	log::info!("Starting configuration watcher...");
	notify_debouncer_full::new_debouncer(
		Duration::from_secs(5),
		None,
		ConfigWatcher {
			config,
			repo_watcher,
		},
	)?
	.watch(
		&confy::get_configuration_file_path("git-autosave", "git-autosaved")?,
		RecursiveMode::NonRecursive,
	)?;
	log::info!("Started configuration watcher");

	log::info!("Initializing complete. Parking...");
	loop {
		std::thread::yield_now();
	}
}

fn init() -> Result<(), anyhow::Error> {
	let repository = Repository::discover(".")?;
	let mut config = Config::load()?;
	let id = git_autosave::init(&repository, Some(&mut config))?;
	config.save()?;

	println!("Initialized autosave for repository: {id}");

	Ok(())
}

fn autosave() -> Result<(), anyhow::Error> {
	let repository = Repository::discover(".")?;
	let gitconfig = repository.config()?;
	let config: &'static mut Config = Box::leak(Box::new(Config::load()?));

	if std::env::args().any(|arg| arg == "--init") {
		let id = git_autosave::init(&repository, Some(config))?;
		config.save()?;
		println!("Initialized autosave for repository: {id}");
	}

	let auth = GitAuthenticator::new().set_prompter(Inquirer(config));
	let mut callbacks = RemoteCallbacks::new();
	callbacks.credentials(auth.credentials(&gitconfig));

	let commit = commit_autosave(&repository)?;
	println!("Commited autosave: {commit}");
	push_autosaves(&repository, callbacks)?;
	println!("Successfully pushed autosave to remote");

	Ok(())
}

fn clean_autosaves() -> Result<(), anyhow::Error> {
	let repository = Repository::discover(".")?;
	for reference in repository.references()? {
		let Ok(mut reference) = reference else {
			continue;
		};
		let Ok(autosave): Result<Autosave, git2::Error> = (&reference).try_into() else {
			continue;
		};

		if Utc::now().timestamp() - autosave.time.seconds() > THREE_MONTHS {
			reference.delete()?;
		}
	}

	Ok(())
}

fn restore_autosave() -> Result<(), anyhow::Error> {
	let all_users = std::env::args().any(|arg| arg == "--all-users");
	let all_branches = std::env::args().any(|arg| arg == "--all-branches");
	let all_devices = std::env::args().any(|arg| arg == "--all-devices");
	let anytime = std::env::args().any(|arg| arg == "--anytime");
	let force = std::env::args().any(|arg| arg == "--force");

	let repository = Repository::discover(".")?;
	let repo_id = git_autosave::repository_id(&repository)?;
	let signature = repository.signature()?;
	let branch = git_autosave::utils::current_branch(&repository)?;
	let earliest_time = repository.head()?.peel_to_commit()?.time();

	let gitconfig = repository.config()?;
	let config: &'static _ = Box::leak(Box::new(Config::load()?));
	let auth = GitAuthenticator::new().set_prompter(Inquirer(config));
	let mut callbacks = RemoteCallbacks::new();
	callbacks.credentials(auth.credentials(&gitconfig));
	git_autosave::fetch_autosaves(&repository, callbacks)?;

	let mut autosaves = git_autosave::autosaves(&repository)?
		.into_iter()
		.filter(|autosave| {
			all_users
				|| signature
					.name()
					.zip(autosave.author.clone())
					.is_some_and(|(a, b)| a == b)
				|| signature
					.email()
					.zip(autosave.email.clone())
					.is_some_and(|(a, b)| a == b)
		})
		.filter(|autosave| all_branches || autosave.branch_name == branch)
		.filter(|autosave| anytime || autosave.time > earliest_time)
		.filter(|autosave| all_devices || autosave.repo_id.as_bytes() != repo_id.as_bytes())
		.collect::<Vec<_>>();

	if autosaves.is_empty() {
		eprintln!("ERROR: There are no available autosaves for the given filters.");
		if !all_users || !all_branches || !anytime {
			eprintln!(
				"hint: Use --all-users, --all-branches, --all-devices, or --anytime to include more options."
			);
		}
		std::process::exit(1);
	}

	let autosave = if autosaves.len() > 1 {
		let autosaves = autosaves
			.into_iter()
			.map(|autosave| {
				let device = autosave.host_name.as_ref().unwrap_or(&autosave.repo_id);
				let time = chrono::DateTime::from_timestamp(autosave.time.seconds(), 0)
					.map(|time| time.with_timezone(&Local))
					.map(|time| time.to_rfc2822())
					.unwrap_or(autosave.time.seconds().to_string());
				let branch = if all_branches {
					format!(" on {}", &autosave.branch_name)
				} else {
					String::new()
				};
				let author = if let Some(author) =
					autosave.author.as_ref().or(autosave.email.as_ref())
					&& all_users
				{
					format!(" by {author}")
				} else {
					String::new()
				};
				AutosaveOption {
					text: format!("{device} ({time}{branch}{author})"),
					value: autosave,
				}
			})
			.collect();
		inquire::Select::new("Select an autosave:", autosaves)
			.prompt()?
			.value
	} else {
		autosaves
			.pop()
			.expect("There should be an autosave to select but there isn't. This is a bug!")
	};
	let autosaved_commit = repository.find_commit(autosave.commit_id)?;
	let workdir = repository.find_tree(git_autosave::utils::workdir_to_tree(&repository)?)?;
	let new_tree =
		git_autosave::utils::merge_commit_with_tree(&repository, &autosaved_commit, &workdir)?;
	git_autosave::save_undo_tree(&repository, &workdir)?;
	git_autosave::saved_restored_autosave(&repository, &autosave)?;

	let mut options = CheckoutBuilder::new();
	if force {
		options.force();
	}
	repository.checkout_tree(
		&repository.find_object(new_tree, Some(git2::ObjectType::Tree))?,
		Some(&mut options),
	)?;

	Ok(())
}

fn subcommand(command: &Path, name: &str, f: fn() -> Result<(), anyhow::Error>) {
	let Some(command) = command.components().next_back() else {
		eprintln!("Invalid binary name: {}", command.to_string_lossy());
		std::process::exit(1);
	};
	if command.as_os_str().to_string_lossy() != name {
		return;
	}

	match f() {
		Ok(()) => std::process::exit(0),
		Err(e) => {
			eprintln!("{e}");
			std::process::exit(1);
		}
	}
}

fn main() {
	let Some(command) = std::env::args_os().next() else {
		eprintln!("No command provided");
		std::process::exit(1);
	};
	let path = PathBuf::from(command);

	subcommand(&path, "git-init-autosave", init);
	subcommand(&path, "git-autosave", autosave);
	subcommand(&path, "git-clean-autosaves", clean_autosaves);
	subcommand(&path, "git-restore-autosave", restore_autosave);
	subcommand(&path, "git-autosave-daemon", daemon);

	eprintln!("Unrecognized command: {}", path.to_string_lossy());
	std::process::exit(1);
}