use anyhow::{anyhow, Result};
use serde::{Deserialize, Serialize};

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Author {
    pub id: i64,
    pub login: String,
    pub full_name: String,
    pub email: String,
    pub avatar_url: String,
    pub language: String,
    pub is_admin: bool,
    pub last_login: String,
    pub created: String,
    pub username: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Release {
    pub id: i64,
    pub tag_name: String,
    pub target_commitish: String,
    pub name: String,
    pub body: String,
    pub url: String,
    pub tarball_url: String,
    pub zipball_url: String,
    pub draft: bool,
    pub prerelease: bool,
    pub created_at: String,
    pub published_at: String,
    pub author: Author,
    pub assets: Vec<Attachment>,
}

use cli_table::{Cell, Row};
impl Release {
    pub fn row(&self) -> Row {
        Row::new(vec![
            Cell::new(&format!("{}", self.id), Default::default()),
            Cell::new(&self.tag_name, Default::default()),
            Cell::new(&self.created_at, Default::default()),
            Cell::new(&self.target_commitish, Default::default()),
            Cell::new(&self.author.username, Default::default()),
            Cell::new(&self.name, Default::default()),
        ])
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateRelease {
    pub body: String,
    pub draft: bool,
    pub name: String,
    pub prerelease: bool,
    pub tag_name: String,
    pub target_commitish: String,
}

pub(crate) async fn get_release_by_tag(
    cli: &reqwest::Client,
    server: &String,
    owner: &String,
    repo: &String,
    tag: &String,
) -> Result<Release> {
    let releases: Vec<Release> = cli
        .get(&format!(
            "{}/api/v1/repos/{}/{}/releases",
            server, owner, repo
        ))
        .send()
        .await?
        .json()
        .await?;

    let mut release: Option<Release> = None;

    for rls in releases {
        if *tag == rls.tag_name {
            release = Some(rls);
        }
    }

    if release.is_none() {
        return Err(anyhow!("tag {} not found", tag));
    }

    Ok(release.unwrap())
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Attachment {
    pub id: i64,
    pub name: String,
    pub size: i64,
    pub download_count: i64,
    pub created_at: String,
    pub uuid: String,
    pub browser_download_url: String,
}

impl Attachment {
    pub fn row(&self) -> Row {
        let size = {
            let bytes = byte_unit::Byte::from_bytes(self.size as u128);
            let unit = bytes.get_appropriate_unit(false);
            unit.to_string()
        };

        Row::new(vec![
            Cell::new(&self.name, Default::default()),
            Cell::new(&size, Default::default()),
            Cell::new(&self.browser_download_url, Default::default()),
        ])
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Repo {
    pub allow_merge_commits: bool,
    pub allow_rebase: bool,
    pub allow_rebase_explicit: bool,
    pub allow_squash_merge: bool,
    pub archived: bool,
    pub avatar_url: String,
    pub clone_url: String,
    pub created_at: String,
    pub default_branch: String,
    pub description: String,
    pub empty: bool,
    pub fork: bool,
    pub forks_count: i64,
    pub full_name: String,
    pub has_issues: bool,
    pub has_pull_requests: bool,
    pub has_wiki: bool,
    pub html_url: String,
    pub id: i64,
    pub ignore_whitespace_conflicts: bool,
    pub mirror: bool,
    pub name: String,
    pub open_issues_count: i64,
    pub open_pr_counter: i64,
    pub original_url: String,
    pub owner: Owner,
    pub permissions: Permissions,
    pub private: bool,
    pub release_counter: i64,
    pub size: i64,
    pub ssh_url: String,
    pub stars_count: i64,
    pub template: bool,
    pub updated_at: String,
    pub watchers_count: i64,
    pub website: String,
}

pub(crate) async fn get_repo(
    cli: &reqwest::Client,
    server: &String,
    owner: &String,
    repo: &String,
) -> Result<Repo> {
    Ok(cli
        .get(&format!("{}/api/v1/repos/{}/{}", server, owner, repo))
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?)
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Owner {
    pub avatar_url: String,
    pub created: String,
    pub email: String,
    pub full_name: String,
    pub id: i64,
    pub is_admin: bool,
    pub language: String,
    pub last_login: String,
    pub login: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Permissions {
    pub admin: bool,
    pub pull: bool,
    pub push: bool,
}

pub(crate) async fn get_attachments_for_release(
    cli: &reqwest::Client,
    server: &String,
    owner: &String,
    repo: &String,
    id: &i64,
) -> Result<Vec<Attachment>> {
    let attachments: Vec<Attachment> = cli
        .get(&format!(
            "{}/api/v1/repos/{}/{}/releases/{}/assets",
            server, owner, repo, id
        ))
        .send()
        .await?
        .json()
        .await?;

    Ok(attachments)
}