#![cfg(target_os = "android")]

/*use jni::{
    objects::{JClass, JString},
    sys::{jboolean, jchar, jint, jstring},
    JNIEnv,
};
use std::{error::Error, fs, net::Ipv4Addr, str};
use clap::{App, Arg, ArgMatches};
use env_logger::Builder;
use log::{error, LevelFilter};
use crate::config::{ ServerConfiguration, ClientConfiguration, ObfsProtocol, ServerPeer };
use fast32::base32::RFC4648;
use crossbeam_channel::unbounded;*/

use ::jni::objects::GlobalRef;
use ::jni::JavaVM;
use robusta_jni::bridge;
use std::sync::OnceLock;

mod config;
mod client;
mod udp;
mod mobile;

static TUN_QUIT: std::sync::Mutex<Option<tokio_util::sync::CancellationToken>> = std::sync::Mutex::new(None);

#[bridge]
mod jni {
    use android_logger::Config;
    use jni::objects::{GlobalRef, JObject, JValue, JString};
    use jni::sys::{jboolean, jchar, jint, jstring};
    use log::{info, trace};
    use robusta_jni::convert::{IntoJavaValue, Signature, TryFromJavaValue, TryIntoJavaValue};
    use robusta_jni::jni::errors::Result as JniResult;
    use robusta_jni::jni::objects::AutoLocal;
    use robusta_jni::jni::JNIEnv;
    use crate::mobile;
    use crate::TUN_QUIT;

    #[derive(Signature, TryIntoJavaValue, IntoJavaValue, TryFromJavaValue)]
    #[package(com.alterdekim.frida)]
    pub struct FridaLib<'env: 'borrow, 'borrow> {
        #[instance]
        raw: AutoLocal<'env, 'borrow>,
    }

    impl<'env: 'borrow, 'borrow> FridaLib<'env, 'borrow> {
        pub extern "jni" fn start(self, env: &JNIEnv, config_b32: String,
            tun_fd: i32,
            close_fd_on_drop: bool) -> JniResult<i32> {
            
            let close_token = tokio_util::sync::CancellationToken::new();
            if let Ok(mut l) = TUN_QUIT.lock() {
                if l.is_some() {
                    return Ok(-1);
                }
                *l = Some(close_token.clone());
            } else {
                return Ok(-2);
            }

            let main_loop = async move {
                /*if let Err(err) =  {
                    FridaLib::traceFromNative(env, format!("main loop error: {}", err));
                    return Err(err);
                }*/
                mobile::mobile_run(config_b32, close_fd_on_drop, tun_fd, /*env, */close_token).await;
            };
        
            let exit_code = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
                Err(_e) => -3,
                Ok(rt) => { rt.spawn(main_loop); -4 } // block_on
            };
        
            Ok(exit_code)
            
            //FridaLib::traceFromNative(env, "Hello world".to_string());

            //Ok(mobile::mobile_run(config_b32, close_fd_on_drop, tun_fd, env))
        }

        pub extern "jni" fn stop(self, env: &JNIEnv) -> JniResult<i32> {
            if let Ok(mut l) = TUN_QUIT.lock() {
                if let Some(close_token) = l.take() {
                    close_token.cancel();
                    return Ok(0);
                }
            }
            Ok(-1)
        }

        pub extern "java" fn traceFromNative(
            env: &JNIEnv,
            text: String,
        ) -> JniResult<()> {

        }
    }
}