#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

use std::fs::File;
use std::io::Write;
use tokio::runtime::Runtime;
use tauri::State;

extern crate ip_lib;
extern crate rand;
extern crate open;

// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command

#[tauri::command]
fn get_version() -> String {
	option_env!("CARGO_PKG_VERSION").unwrap_or("x.x.x").to_string()
}

#[tauri::command]
fn create_entry(name: String, username: String, pw: &str, mpw: String) -> bool {
	let return_value = ip_lib::create_entry(&name, username+";"+pw, mpw);
	if return_value {
		isync_save();
	}
	return_value
}

#[tauri::command]
fn random_password() -> String {
	ip_lib::random_password()
}

#[tauri::command]
fn get_entry(name: String, mpw: String) -> Result<(String,String),String> {
	let binding = ip_lib::get_entry(&name, mpw);
	if let Ok(data) = binding {
		let mut split = data.split(';');
		Ok((split.next().unwrap().to_string(),split.next().unwrap().to_string()))
	} else {
		Err(binding.expect_err("expected error"))
	}
}

#[tauri::command]
fn get_entries() -> Vec<String> {
	let mut vector: Vec<String> = Vec::default();
	for entry in ip_lib::get_entries() {
		let entry_filename = entry.unwrap().file_name();
		let ent = entry_filename.to_str().unwrap();
		if ent != "token.ipasst" && ent.len()>6 {
			vector.insert(0, ent[..ent.len()-6].to_string());
		}
	}

	vector.sort();

	vector
}

#[tauri::command]
fn remove_entry(name: &str) -> bool {
	let filepath = &(ip_lib::get_ipass_folder()+name+".ipass");
	if std::path::Path::new(filepath).exists() {
		std::fs::remove_file(filepath).unwrap();
		isync_save();
		return true;
	}
	false
}

#[tauri::command]
fn open_authorize() -> u32 {
	let code:u32 = rand::random();
    open::that(format!("https://ipost.rocks/authorize?id=1&extra={}",code)).unwrap();
	//the IPass app id is 1
	code
}

#[tauri::command]
fn store_token(token: String) {
	let filepath = &(ip_lib::get_ipass_folder()+"token.ipasst");
	let mut file = File::create(filepath).unwrap();
    file.write_all(token.as_bytes()).unwrap();
}

#[tauri::command]
fn remove_token() {
	let filepath = &(ip_lib::get_ipass_folder()+"token.ipasst");
	std::fs::remove_file(filepath).unwrap();
	//TODO: cleaner solution via IPass api call to unauthorize
}

#[tauri::command]
fn get_isync_status() -> bool {
	let filepath = &(ip_lib::get_ipass_folder()+"token.ipasst");
	std::path::Path::new(filepath).exists()
}

fn isync_save() {
	let isync_save_future = ip_lib::isync_save();

	let rt = Runtime::new().unwrap();
	let _save_output = rt.block_on(isync_save_future);
	//println!("isync_save: {}",save_output);
}

#[tauri::command]
fn sync_isync(rt: State<Runtime>) {
	//println!("going to sync");
	rt.spawn(async {
		let _get_output = ip_lib::isync_get().await;
		//println!("isync_get: {}",_get_output);
	});
}

fn main() {
	let rt = Runtime::new().unwrap();

	tauri::Builder::default()
		.invoke_handler(tauri::generate_handler![
			get_version,create_entry,random_password,
			get_entry,get_entries,remove_entry,
			open_authorize,store_token,get_isync_status,
			sync_isync,remove_token])
		.manage(rt)
		.run(tauri::generate_context!())
		.expect("error while running tauri application");
}