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

use std::collections::HashMap;
use std::str::FromStr;
use std::sync::Mutex;
// use tokio::runtime::Runtime;

use serde::{Serialize, Deserialize};
use tauri::{Manager, State};
use tokio::sync::oneshot;

mod storage;
mod http;


fn main() {
  tauri::Builder::default()
    .manage(CurrentSession)
    .manage(RequestCount)
    .manage(OpenRequests)
    .invoke_handler(tauri::generate_handler![unlock])
    .setup(|app| {
      let addr = std::net::SocketAddrV4::from_str("127.0.0.1:12345").unwrap();
      tauri::async_runtime::spawn(http::serve(addr, app.handle()));
      Ok(())
    })
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

  // let addr = std::net::SocketAddrV4::from_str("127.0.0.1:12345").unwrap();
  // let rt = Runtime::new().unwrap();

  // rt.block_on(http::serve(addr)).unwrap();

  // let creds = std::fs::read_to_string("credentials.json").unwrap();
  // storage::save(&creds, "correct horse battery staple");
}

#[derive(Serialize, Deserialize)]
pub enum Session {
  Unlocked(String),
  Locked,
  Empty,
}

type CurrentSession = Mutex<Session>;
type RequestCount = Mutex<u64>;
type OpenRequests = Mutex<HashMap<u64, oneshot::Sender>>;

#[derive(Clone, Serialize, Deserialize)]
pub struct CredentialsRequest {
  pub request_id: u64,
}


// struct Session {
//   key_id: String,
//   secret_key: String,
//   token: String,
//   expires: u64,
// }


#[tauri::command]
fn unlock(passphrase: String, current_session: State<'_, CurrentSession>) -> bool {
  let credentials = storage::load(&passphrase);
  *current_session.lock().unwrap() = CredentialStatus::Unlocked(credentials);
  true
}