Custom Mods

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LoaderMod {
    #[serde(default)]
    pub required: bool,
    #[serde(default)]
    #[serde(alias = "default")]
    pub enabled: bool,
    pub name: String,
    pub source: ModSource,
}

/// Request list of downloadable mods for mc_version and used subsystem
pub async fn fetch_mods(&self, mc_version: &str, subsystem: &str) -> Result<Vec<LoaderMod>> {
    self.request_from_endpoint(
        API_V1, 
        &format!("version/mods/{}/{}", mc_version, subsystem)
    )
    .await
}

#[tauri::command]
pub(crate) async fn request_mods(
    client: Client,
    mc_version: &str,
    subsystem: &str,
) -> Result<Vec<LoaderMod>, String> {
    let mods = (|| async { client.fetch_mods(&mc_version, &subsystem).await })
        .retry(ExponentialBuilder::default())
        .notify(|err, dur| {
            warn!("Failed to request mods. Retrying in {:?}. Error: {}", dur, err);
        })
        .await
        .map_err(|e| format!("unable to request mods: {:?}", e))?;

    Ok(mods)
}

#[tauri::command]
pub(crate) async fn get_custom_mods(
    branch: &str,
    mc_version: &str,
) -> Result<Vec<LoaderMod>, String> {
    let data = LAUNCHER_DIRECTORY.data_dir();
    let mod_cache_path = data
        .join("custom_mods")
        .join(format!("{}-{}", branch, mc_version));

    if !mod_cache_path.exists() {
        return Ok(vec![]);
    }

    let mut mods = vec![];
    let mut mods_read = fs::read_dir(&mod_cache_path)
        .await
        .map_err(|e| format!("unable to read custom mods: {:?}", e))?;

    while let Some(entry) = mods_read
        .next_entry()
        .await
        .map_err(|e| format!("unable to read custom mods: {:?}", e))?
    {
        let file_type = entry
            .file_type()
            .await
            .map_err(|e| format!("unable to read custom mods: {:?}", e))?;
        let file_name = entry.file_name().to_str().unwrap().to_string();

        if file_type.is_file() && file_name.ends_with(".jar") {
            // todo: pull name from JAR manifest
            let file_name_without_extension = file_name.replace(".jar", "");

            mods.push(LoaderMod {
                required: false,
                enabled: true,
                name: file_name_without_extension,
                source: ModSource::Local { file_name },
            });
        }
    }

    Ok(mods)
}

#[tauri::command]
pub(crate) async fn delete_custom_mod(
    branch: &str,
    mc_version: &str,
    mod_name: &str,
) -> Result<(), String> {
    let data = LAUNCHER_DIRECTORY.data_dir();
    let mod_cache_path = data
        .join("custom_mods")
        .join(format!("{}-{}", branch, mc_version));

    if !mod_cache_path.exists() {
        return Ok(());
    }

    let mod_path = mod_cache_path.join(mod_name);

    if mod_path.exists() {
        fs::remove_file(mod_path)
            .await
            .map_err(|e| format!("unable to delete custom mod: {:?}", e))?;
    }

    Ok(())
}

impl ModSource {
    pub fn get_path(&self) -> Result<String> {
        Ok(match self {
            ModSource::SkipAd { artifact_name, .. } => {
                format!("{}.jar", artifact_name)
            }
            ModSource::Repository { artifact, .. } => {
                get_maven_artifact_path(artifact)?
            }
            ModSource::Local { file_name } => {
                file_name.clone()
            }
        })
    }
}

pub(crate) async fn run_client(
    client: Client,
    build_id: u32,
    options: Options,
    mods: Vec<LoaderMod>,
    window: Window,
    app_state: tauri::State<'_, AppState>,
) -> Result<(), String> {
    // ...
    let launch_manifest = client.fetch_launch_manifest(build_id).await?;
    
    prelauncher::launch(
        launch_manifest, 
        parameters, 
        mods,  // Custom mods merged with default mods
        launcher_data
    ).await
    // ...
}

pub async fn launch(
    launch_manifest: LaunchManifest,
    parameters: StartParameter,
    additional_mods: Vec<LoaderMod>,
    launcher_data: LauncherData<'_, Box<ShareableWindow>>,
) -> Result<()> {
    // Merge launch_manifest.mods with additional_mods
    // ...
}

/// Resolve direct download link from skip file pid
pub async fn resolve_skip_file(
    &self,
    client_account: &ClientAccount,
    pid: &str,
) -> Result<SkipFileResolve> {
    self.request_with_client_account(
        &format!("file/resolve/{}", pid), 
        client_account
    )
    .await
}

/// Uses [self.url] to create a direct download link for a file with the given pid
pub fn get_direct_download_link(&self, pid: &str) -> String {
    format!("{}/{}/file/{}", self.url, API_V3, pid)
}

#[derive(Deserialize)]
pub struct LaunchManifest {
    pub repositories: BTreeMap<String, String>,
    pub mods: Vec<LoaderMod>,
    // ...
}