pub mod jvm_deps;

#[cfg(target_os = "linux")]
pub mod jvm_deps_linux;
#[cfg(target_os = "macos")]
pub mod jvm_deps_mac;
#[cfg(target_os = "windows")]
pub mod jvm_deps_windows;



// Deps for run_deployed_app
use app_dirs::AppInfo;
use j4rs;
use j4rs::{InvocationArg};
use std::convert::TryFrom;
use url::Url;
use std::path::{Path};
use std::fs;
use std::fs::File;

/**
 * This function abstracts over downloading a  given j4rs runtime tarball,
 * a hardcoded copy of OpenJDK 13, any number of maven dependencies
 * from a list of maven repositories, and
 * finally calling a true void method on any given class.
 */
pub fn run_deployed_app(
  app_name: &'static str,
  app_author: &'static str,
  rj_deps_tar_gz_url: &str,
  maven_repos: Vec<&str>,
  java_ops: Vec<&str>,
  maven_dependencies: Vec<&str>,
  http_jar_dependencies: Vec<&str>,
  explicit_class_directory: Option<String>, // When Some() this will load classes via a URLClassLoader from the given path.
  main_class_name: &str,
  main_class_void_method_name: &str
) -> Result<(), String> {
  
  let app_info = AppInfo {
    name: app_name,
    author: app_author
  };
  // JVM dependencies come from the OpenJDK build and are hard-coded
  jvm_deps::ensure_jvm_exists(app_info.clone()).unwrap();
  
  match jvm_deps::get_j4rs_basedir(
    // Projects will need to be responsible for hosting these dependencies
    rj_deps_tar_gz_url,
    app_info.clone()
  ) {
    Err(e) => {
      return Err(format!("Error downloading j4rs dependencies: {}", e));
    }
    Ok(j4s_base_path) => {
      println!("j4s_base_path={}", j4s_base_path);
      
      let mut maven_repo_structs: Vec<j4rs::MavenArtifactRepo> = Vec::new();
      for repo_url in maven_repos {
        maven_repo_structs.push(j4rs::MavenArtifactRepo::from(repo_url));
      }
      
      let mut java_op_structs: Vec<j4rs::JavaOpt> = Vec::new();
      for op in java_ops {
        java_op_structs.push(j4rs::JavaOpt::new(op));
      }
      
      let jvm_build_res = if let Some(explicit_class_directory) = explicit_class_directory.clone() {
        println!("Adding {} to classpath...", explicit_class_directory);
        // This overrides the class path search performed by JvmBuilder.build(),
        // so we duplicate that logic here.
        let sep_char = if cfg!(target_os = "windows") { ";" } else { ":" };
        
        let tmp = format!("-Djava.class.path={}{}{}",
          &explicit_class_directory, &sep_char,
          get_default_j4rs_classpath(&j4s_base_path)
        );
        
        java_op_structs.push(j4rs::JavaOpt::new(&tmp));
        j4rs::JvmBuilder::new()
          .with_base_path(&j4s_base_path)
          .with_maven_settings(j4rs::MavenSettings::new(maven_repo_structs))
          .java_opts(java_op_structs)
          .build()
      }
      else {
        j4rs::JvmBuilder::new()
          .with_base_path(&j4s_base_path)
          .with_maven_settings(j4rs::MavenSettings::new(maven_repo_structs))
          .java_opts(java_op_structs)
          .build()
      };
      
      match jvm_build_res {
        Ok(jvm) => {
          
          // Now we can load things into the JVM
          // Maven artifacts will be downloaded once and persisted under j4s_base_path
          
          for lib in maven_dependencies {
            let app_artifact = j4rs::MavenArtifact::from(lib);
            jvm.deploy_artifact(&app_artifact).unwrap();
          }
          
          // Now download .jar files (useful when maven deployments are broken)
          for http_jar_url in http_jar_dependencies {
            if ! (http_jar_url.ends_with(".jar") || http_jar_url.ends_with(".JAR")) {
              continue;
            }
            let u = Url::parse(&http_jar_url).unwrap();
            
            let mut asset_path = Path::new(&j4s_base_path).to_path_buf();
            asset_path.push("jassets");
            asset_path.push(
              u.path_segments().unwrap().collect::<Vec<&str>>().pop().unwrap_or("")
            );
            
            if ! asset_path.exists() {
              println!("Downloading {} to {:?}", http_jar_url, asset_path);
              match reqwest::get(http_jar_url) {
                Ok(mut response) => {
                  match File::create(asset_path) {
                    Ok(mut dest) => {
                      match std::io::copy(&mut response, &mut dest) {
                        Ok(_) => {
                          // File downloaded, fall through to next block for extraction
                        }
                        Err(e) => {
                          return Err(format!("{}", e));
                        }
                      }
                    }
                    Err(e) => {
                      return Err(format!("{}", e));
                    }
                  }
                }
                Err(e) => {
                  return Err(format!("{}", e));
                }
              }
            }
          }
          
          // If this is the first run j4rs will not be able to put
          // the contents of j4s_base_path/jassets/*.jar on the classpath.
          // To work around this we ALWAYS:
          //  - generate a URL[]{ } of all .jar files under jassets
          //  - create our own URLClassLoader
          //  - use that loader to invoke the given static void class & method
          
          println!("Creating URLClassLoader...");
          let mut asset_path = Path::new(&j4s_base_path).to_path_buf();
          asset_path.push("jassets");
          
          let mut url_objects = vec![];
          
          // Windows systems need a delay before reading a directory...
          if cfg!(target_os = "windows") {
            std::thread::sleep(std::time::Duration::from_millis(80));
          }
          
          // IF we were given a directory of class files, push that to our URL[] first
          if let Some(mut explicit_class_directory) = explicit_class_directory.clone() {
            if ! explicit_class_directory.ends_with("/") {
              explicit_class_directory.push_str("/");
            }
            let entry_string = format!("file://{}", explicit_class_directory);
            //println!("entry_string={}", entry_string);
            if let Ok(java_url_string) = InvocationArg::try_from(entry_string) {
              // java.lang.String ^^
              let java_url = jvm.create_instance(
                "java.net.URL",
                &[java_url_string]
              ).unwrap();
              url_objects.push(InvocationArg::from(java_url));
            }
          }
          
          for entry in fs::read_dir(asset_path).unwrap() {
            if let Ok(entry) = entry {
              let entry_string: String = entry.path().as_path().to_string_lossy().to_string();
              let entry_string = format!("file://{}", entry_string);
              //println!("entry_string={}", entry_string);
              if let Ok(java_url_string) = InvocationArg::try_from(entry_string) {
                // java.lang.String ^^
                let java_url = jvm.create_instance(
                  "java.net.URL",
                  &[java_url_string]
                ).unwrap();
                url_objects.push(InvocationArg::from(java_url));
              }
            }
          }
          
          let url_classloader = jvm.create_instance(
            "java.net.URLClassLoader",
            &[
              InvocationArg::Java {
                instance: jvm.create_java_array("java.net.URL", &url_objects).unwrap(),
                class_name: "java.net.URL".to_string(),
                serialized: false,
              }
            ]
          ).unwrap();
          let true_boolean_obj = jvm.create_instance(
              "java.lang.Boolean",
              &vec![
                InvocationArg::try_from("true").unwrap(),
              ],
          ).unwrap();
          let true_boolean_primitive = jvm.invoke(
            &true_boolean_obj,
            "booleanValue",
            &vec![]
          ).unwrap();
          let classloader = jvm.cast(&url_classloader, "java.lang.ClassLoader").unwrap();
          
          let class_obj = jvm.invoke_static(
            "java.lang.Class",
            "forName",
            &vec![
              InvocationArg::try_from(main_class_name).unwrap(),
              //InvocationArg::try_from(true).unwrap().into_primitive().unwrap(),
              InvocationArg::from(true_boolean_primitive),
              InvocationArg::from(classloader),
            ]
          ).unwrap();
          let method_obj = jvm.invoke(
            &class_obj,
            "getDeclaredMethod",
            &vec![
              InvocationArg::try_from(main_class_void_method_name).unwrap(),
              InvocationArg::from(jvm.create_java_array("java.lang.Class", &vec![]).unwrap()),
            ]
          ).unwrap();
          let main_class_instance = jvm.invoke(
            &class_obj,
            "newInstance",
            &vec![]
          ).unwrap();
          
          println!("Rust is invoking {}.{}() using reflection ...", main_class_name, main_class_void_method_name);
          let _method_invoke_res = jvm.invoke(
            &method_obj,
            "invoke",
            &vec![
              InvocationArg::from(main_class_instance),
              InvocationArg::from(jvm.create_java_array("java.lang.Object", &vec![]).unwrap()),
            ]
          );
          
          println!("Rust is exiting...");
          
        }
        Err(e) => {
          return Err(format!("e={:?}", e));
        }
      }
    }
  }
  
  Ok(())
}

fn get_default_j4rs_classpath(j4s_base_path: &str) -> String {
  use std::path::{PathBuf};
  use fs_extra::dir::get_dir_content;
  
  let mut jassets_path = PathBuf::from(j4s_base_path);
  jassets_path.push("jassets");
  
  let all_jars = get_dir_content(&jassets_path).expect("Could not read j4rs dir").files;
  // This is the j4rs jar that should be included in the classpath
  //let j4rs_jar_to_use = format!("j4rs-{}-jar-with-dependencies.jar", j4rs_version());
  let j4rs_jar_to_use = format!("j4rs-0.10.0-jar-with-dependencies.jar"); // TODO hardcoded but we need to detect off tar.gz contents?
  // Filter out possible incorrect jars of j4rs
  let filtered_jars: Vec<String> = all_jars.into_iter()
      .filter(|jar| {
          !jar.contains("j4rs-") || jar.ends_with(&j4rs_jar_to_use)
      })
      .collect();
  let sep_char = if cfg!(target_os = "windows") { ";" } else { ":" };
  let cp_string = filtered_jars.join(sep_char);
  return cp_string;  
}