use std::{fs, path::Path};

use crate::structs::package::{Package, PackageType};

/// Gets all packages of an owner
///
/// https://github.com/go-gitea/gitea/blob/main/routers/api/v1/packages/package.go#L22
///
/// Matches the route `GET /packages/{owner}`
pub async fn list_packages(
    client: &reqwest::Client,
    gitea_url: &str,
    owner: &str,
    pkg_type: Option<PackageType>,
) -> crate::Result<Vec<Package>> {
    let request_url = format!("{gitea_url}/api/v1/packages/{owner}");
    // add the query parameter only when a package type filter has been set.
    let request_url = if let Some(pkg_type) = pkg_type {
        let pkg_type = pkg_type.to_string();
        format!("{request_url}?type={pkg_type}")
    } else {
        request_url
    };
    let req = client.get(request_url).send().await;
    let response = req.map_err(crate::Error::WrappedReqwestErr)?;

    if response.status().is_success() {
        let release_list = response
            .json::<Vec<Package>>()
            .await
            .map_err(crate::Error::WrappedReqwestErr)?;
        return Ok(release_list);
    } else if response.status().is_client_error() {
        let mesg = crate::decode_client_error(response).await?;
        return Err(crate::Error::ApiErrorMessage(mesg));
    }
    panic!("Reached the end of `api::list_packages()` without matching a return pathway.");
}

pub fn get_packages() {}
pub fn delete_package() {}
pub fn list_package_files() {}
pub fn get_latest_package_version() {}
pub fn link_package() {}
pub fn unlink_package() {}
pub fn search_packages() {}


/// Upload a Debian package and link it to it's source repository
fn upload_debian(
    client: &reqwest::Client,
    gitea_url: &str,
    repo: &str,
    file: &Path,
    owner: &str,
    distribution: &str,
    component: &str,
) -> crate::Result<()> {
    let request_url = format!("{gitea_url}/api/packages/{owner}/debian/pool/{distribution}/{component}/upload");
    match file.try_exists() {
        Ok(true) => (),
        Ok(false) => return Err(crate::Error::NoSuchFile),
        Err(e) => {
            eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
            panic!(
                "TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
            );
        }
    };

    let data = reqwest::multipart::Part::stream(fs::read(&file).unwrap())
        .file_name("deb-pkg")
        .mime_str("text/plain")?;

    Ok(())
}

/// Uploads a package file to the Gitea registry.
/// 
/// This route is not documented in Swagger. The reason seems to be that some
/// package managers have their own upload protocol (e.g. `docker push`). Gitea
/// implements it but does not define it, so it doesn't include the API docs.
pub fn upload_package(
    client: &reqwest::Client,
    gitea_url: &str,
    file: String, // TODO: Use a path buffer of some flavor.
) {
    let request_url = format!("{gitea_url}/{}", route_for_upload(PackageType::Debian));
}

fn route_for_upload(kind: PackageType) -> &'static str {
    match kind {
        PackageType::Alpine => "https://gitea.example.com/api/packages/{owner}/alpine/{branch}/{repository}",
        PackageType::Arch => "api/packages/{owner}/arch/{repository}",
        PackageType::Cargo => todo!(),
        PackageType::Chef => todo!(),
        PackageType::Composer => todo!(),
        PackageType::Conan => todo!(),
        PackageType::Conda => todo!(),
        PackageType::Container => todo!(),
        PackageType::Cran => todo!(),
        PackageType::Debian => "https://gitea.example.com/api/packages/{owner}/debian/pool/{distribution}/{component}/upload",
        PackageType::Generic => todo!(),
        PackageType::Go => todo!(),
        PackageType::Helm => todo!(),
        PackageType::Maven => todo!(),
        PackageType::Npm => todo!(),
        PackageType::Nuget => todo!(),
        PackageType::Pub => todo!(),
        PackageType::PyPi => todo!(),
        PackageType::Rpm => todo!(),
        PackageType::RubyGems => todo!(),
        PackageType::Swift => todo!(),
        PackageType::Vagrant => todo!(),
    }
}