use chrono::offset::Utc;
use rand::prelude::*;
use rusqlite::{types::ToSqlOutput, Connection, ToSql};
use tauri::{Manager, State};
use tokio::sync::Mutex;

mod data_door;

use data_door::DoorState;

struct AppState {
	db: Connection,
	acc: i64,
}

#[derive(Clone, Copy)]
enum Store {
	Aldi,
	Edeka,
	Dm,
	Lidl,
	Rewe,
	Tegut,
}

impl TryFrom<&str> for Store {
	type Error = ();

	fn try_from(s: &str) -> Result<Self, Self::Error> {
		match s {
			"aldi" => Ok(Store::Aldi),
			"edeka" => Ok(Store::Edeka),
			"dm" => Ok(Store::Dm),
			"lidl" => Ok(Store::Lidl),
			"rewe" => Ok(Store::Rewe),
			"tegut" => Ok(Store::Tegut),
			_ => Err(()),
		}
	}
}

impl ToSql for Store {
	fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
		match self {
			Store::Aldi => 0.to_sql(),
			Store::Edeka => 1.to_sql(),
			Store::Dm => 2.to_sql(),
			Store::Lidl => 3.to_sql(),
			Store::Rewe => 4.to_sql(),
			Store::Tegut => 5.to_sql(),
		}
	}
}

#[tauri::command]
async fn swap(
	store: &str,
	state: State<'_, Mutex<AppState>>,
) -> Result<(), ()> {
	let state = state.lock().await;
	let mut rng = rand::thread_rng();
	let store: Store = store.try_into()?;
	state.db.execute(
		"INSERT INTO swap VALUES (?1, ?2, ?3, ?4, ?5)",
		(
			rng.gen::<i64>(),
			store,
			state.acc,
			Utc::now().timestamp(),
			false,
		),
	)
	.map_err(|_| ())?;
	Ok(())
}

#[tauri::command]
async fn count(state: State<'_, Mutex<AppState>>) -> Result<String, ()> {
	let state = state.lock().await;
	let mut stmt = state.db.prepare("SELECT COUNT(*) FROM swap").unwrap();
	let mut rows = stmt.query([]).unwrap();
	let row = rows.next().unwrap().unwrap();
	let cnt: u64 = row.get_unwrap(0);
	Ok(cnt.to_string())
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
	let mut rng = rand::thread_rng();
	let db = Connection::open_in_memory().expect("Failed to create DB.");
	let acc = rng.gen::<i64>();
	db.execute(
		"CREATE TABLE swap (
			rand INTEGER,
			store INTEGER,
			account INTEGER,
			time INTEGER,
			cancellation BOOL
		)",
		(),
	)
	.unwrap();
	let state = AppState { db, acc };
	let door = DoorState::new();
	tauri::Builder::default()
		.plugin(tauri_plugin_fs::init())
		.setup(|app| {
			app.manage(Mutex::new(door));
			app.manage(Mutex::new(state));
			Ok(())
		})
		.plugin(tauri_plugin_opener::init())
		.invoke_handler(tauri::generate_handler![
			swap,
			count,
			data_door::pull_data,
			data_door::push_data,
		])
		.run(tauri::generate_context!())
		.expect("error while running tauri application");
}