use std::{error::Error, io::Read};

use gotcha_gitea::{
    Client, CreateIssue, EditIssue, IssueQuery,
    models::{
        ChangedFile, Comment, Commit, CreateIssueOption, CreateMilestoneOption,
        CreatePullRequestOption, EditIssueOption, EditMilestoneOption, EditPullRequestOption,
        Issue, MergePullRequestOption, Milestone, PullRequest, PullReview,
    },
    pull_state,
};
use serde::{Deserialize, de::DeserializeOwned};

use crate::{
    config::{RepositoryScope, Selection},
    print_table,
};

const ISSUE_HELP: &str = "\
Usage: gotcha issue SUBCOMMAND

Subcommands:
  list [OWNER/REPOSITORY] [OPTIONS]
                                  List and filter issues
  show INDEX [OWNER/REPOSITORY]    Show an issue
  create [OWNER/REPOSITORY]        Create from CreateIssueOption YAML on stdin
  edit INDEX... [OWNER/REPOSITORY] Edit issues from EditIssueOption YAML on stdin
  close INDEX... [OWNER/REPOSITORY]
                                  Close one or more issues
  reopen INDEX... [OWNER/REPOSITORY]
                                  Reopen one or more issues
  delete INDEX [OWNER/REPOSITORY]  Delete an issue
  comments INDEX [OWNER/REPOSITORY]
                                  List comments
  comment INDEX [OWNER/REPOSITORY] Add a comment read as text from stdin";

const MILESTONE_HELP: &str = "\
Usage: gotcha milestone SUBCOMMAND

Subcommands:
  list [OWNER/REPOSITORY]       List milestones
  show ID [OWNER/REPOSITORY]    Show a milestone
  create [OWNER/REPOSITORY]     Create from CreateMilestoneOption YAML on stdin
  edit ID [OWNER/REPOSITORY]    Edit from EditMilestoneOption YAML on stdin
  delete ID [OWNER/REPOSITORY]  Delete a milestone";

const PULL_HELP: &str = "\
Usage: gotcha pull SUBCOMMAND

Subcommands:
  list [OWNER/REPOSITORY]          List pull requests
  show INDEX [OWNER/REPOSITORY]    Show a pull request
  create [OWNER/REPOSITORY]        Create from CreatePullRequestOption YAML on stdin
  edit INDEX [OWNER/REPOSITORY]    Edit from EditPullRequestOption YAML on stdin
  merge INDEX [OWNER/REPOSITORY]   Merge from MergePullRequestOption YAML on stdin
  commits INDEX [OWNER/REPOSITORY] List commits
  files INDEX [OWNER/REPOSITORY]   List changed files
  reviews INDEX [OWNER/REPOSITORY] List reviews";

pub fn domain_help(domain: &str) -> Option<&'static str> {
    match domain {
        "issue" => Some(ISSUE_HELP),
        "milestone" => Some(MILESTONE_HELP),
        "pull" => Some(PULL_HELP),
        _ => None,
    }
}

pub fn subcommand_help(domain: &str, command: &str) -> Option<&'static str> {
    match (domain, command) {
        ("issue", "list") => Some(
            "Usage: gotcha issue list [OWNER/REPOSITORY] [OPTIONS]\n\nOptions:\n  --state open|closed|all\n  -K, --kind issues|pulls|all\n  -k, --keyword TEXT\n  -L, --labels NAMES\n  -m, --milestones NAMES\n  -A, --author USER\n  -a, --assignee USER\n  -M, --mentions USER\n  -F, --from TIMESTAMP\n  -u, --until TIMESTAMP\n  -p, --page NUMBER\n      --limit NUMBER",
        ),
        ("issue", "show") => Some("Usage: gotcha issue show INDEX [OWNER/REPOSITORY]"),
        ("issue", "create") => Some(
            "Usage: gotcha issue create [OWNER/REPOSITORY] < issue.yaml\n\nReads CreateIssueOption YAML from stdin. label_names and milestone_name accept display names, for example:\n  title: Fix the bug\n  body: Reproduction steps\n  label_names: [bug, critical]\n  milestone_name: Version 1.0",
        ),
        ("issue", "edit") => Some(
            "Usage: gotcha issue edit INDEX... [OWNER/REPOSITORY] < issue.yaml\n\nReads EditIssueOption YAML from stdin and applies it to every index. milestone_name resolves a display name; add_labels and remove_labels accept label names; add_assignees adds users without replacing existing assignees.",
        ),
        ("issue", "close") => Some("Usage: gotcha issue close INDEX... [OWNER/REPOSITORY]"),
        ("issue", "reopen") => Some("Usage: gotcha issue reopen INDEX... [OWNER/REPOSITORY]"),
        ("issue", "delete") => Some("Usage: gotcha issue delete INDEX [OWNER/REPOSITORY]"),
        ("issue", "comments") => Some("Usage: gotcha issue comments INDEX [OWNER/REPOSITORY]"),
        ("issue", "comment") => Some(
            "Usage: gotcha issue comment INDEX [OWNER/REPOSITORY] < comment.txt\n\nReads the comment body as text from stdin.",
        ),
        ("milestone", "list") => Some("Usage: gotcha milestone list [OWNER/REPOSITORY]"),
        ("milestone", "show") => Some("Usage: gotcha milestone show ID [OWNER/REPOSITORY]"),
        ("milestone", "create") => Some(
            "Usage: gotcha milestone create [OWNER/REPOSITORY] < milestone.yaml\n\nReads CreateMilestoneOption YAML from stdin, for example:\n  title: Version 1.0\n  due_on: 2026-09-01T00:00:00Z",
        ),
        ("milestone", "edit") => Some(
            "Usage: gotcha milestone edit ID [OWNER/REPOSITORY] < milestone.yaml\n\nReads EditMilestoneOption YAML from stdin.",
        ),
        ("milestone", "delete") => Some("Usage: gotcha milestone delete ID [OWNER/REPOSITORY]"),
        ("pull", "list") => Some("Usage: gotcha pull list [OWNER/REPOSITORY]"),
        ("pull", "show") => Some("Usage: gotcha pull show INDEX [OWNER/REPOSITORY]"),
        ("pull", "create") => Some(
            "Usage: gotcha pull create [OWNER/REPOSITORY] < pull.yaml\n\nReads CreatePullRequestOption YAML from stdin, for example:\n  title: Add feature\n  head: feature\n  base: main",
        ),
        ("pull", "edit") => Some(
            "Usage: gotcha pull edit INDEX [OWNER/REPOSITORY] < pull.yaml\n\nReads EditPullRequestOption YAML from stdin.",
        ),
        ("pull", "merge") => Some(
            "Usage: gotcha pull merge INDEX [OWNER/REPOSITORY] < merge.yaml\n\nReads MergePullRequestOption YAML from stdin, for example:\n  Do: squash\n  delete_branch_after_merge: true",
        ),
        ("pull", "commits") => Some("Usage: gotcha pull commits INDEX [OWNER/REPOSITORY]"),
        ("pull", "files") => Some("Usage: gotcha pull files INDEX [OWNER/REPOSITORY]"),
        ("pull", "reviews") => Some("Usage: gotcha pull reviews INDEX [OWNER/REPOSITORY]"),
        _ => None,
    }
}

#[derive(Debug, PartialEq)]
struct IssueListOptions {
    repository: Option<String>,
    state: String,
    kind: String,
    keyword: Option<String>,
    labels: Option<String>,
    milestones: Option<String>,
    author: Option<String>,
    assignee: Option<String>,
    mentions: Option<String>,
    from: Option<String>,
    until: Option<String>,
    page: i32,
    limit: i32,
}

#[derive(Deserialize)]
struct CreateIssueInput {
    #[serde(flatten)]
    issue: CreateIssueOption,
    #[serde(default)]
    label_names: Vec<String>,
    milestone_name: Option<String>,
}

#[derive(Clone, Deserialize)]
struct EditIssueInput {
    #[serde(flatten)]
    issue: EditIssueOption,
    #[serde(default)]
    add_labels: Vec<String>,
    #[serde(default)]
    remove_labels: Vec<String>,
    #[serde(default)]
    add_assignees: Vec<String>,
    milestone_name: Option<String>,
}

impl Default for IssueListOptions {
    fn default() -> Self {
        Self {
            repository: None,
            state: "open".into(),
            kind: "issues".into(),
            keyword: None,
            labels: None,
            milestones: None,
            author: None,
            assignee: None,
            mentions: None,
            from: None,
            until: None,
            page: 1,
            limit: 30,
        }
    }
}

fn parse_issue_list(arguments: &[String]) -> Result<IssueListOptions, Box<dyn Error>> {
    let mut options = IssueListOptions::default();
    let mut index = 0;
    while index < arguments.len() {
        let argument = arguments[index].as_str();
        let value = |index: &mut usize| -> Result<String, Box<dyn Error>> {
            *index += 1;
            arguments
                .get(*index)
                .cloned()
                .ok_or_else(|| format!("{argument} requires a value").into())
        };
        match argument {
            "--state" => options.state = value(&mut index)?,
            "-K" | "--kind" => options.kind = value(&mut index)?,
            "-k" | "--keyword" => options.keyword = Some(value(&mut index)?),
            "-L" | "--labels" => options.labels = Some(value(&mut index)?),
            "-m" | "--milestones" => options.milestones = Some(value(&mut index)?),
            "-A" | "--author" => options.author = Some(value(&mut index)?),
            "-a" | "--assignee" => options.assignee = Some(value(&mut index)?),
            "-M" | "--mentions" => options.mentions = Some(value(&mut index)?),
            "-F" | "--from" => options.from = Some(value(&mut index)?),
            "-u" | "--until" => options.until = Some(value(&mut index)?),
            "-p" | "--page" => options.page = positive_i32(&value(&mut index)?, "page")?,
            "--limit" | "--lm" => options.limit = positive_i32(&value(&mut index)?, "limit")?,
            unknown if unknown.starts_with('-') => {
                return Err(format!("unknown issue list option {unknown:?}").into());
            }
            repository if options.repository.is_none() => {
                RepositoryScope::parse(repository)?;
                options.repository = Some(repository.into());
            }
            value => return Err(format!("unexpected issue list argument {value:?}").into()),
        }
        index += 1;
    }
    if !matches!(options.state.as_str(), "open" | "closed" | "all") {
        return Err("--state must be open, closed, or all".into());
    }
    if !matches!(options.kind.as_str(), "issues" | "pulls" | "all") {
        return Err("--kind must be issues, pulls, or all".into());
    }
    Ok(options)
}

fn positive_i32(value: &str, name: &str) -> Result<i32, Box<dyn Error>> {
    let value: i32 = value.parse()?;
    if value < 1 {
        return Err(format!("{name} must be a positive integer").into());
    }
    Ok(value)
}

fn issue_targets(arguments: &[String]) -> Result<(Vec<i64>, Option<String>), Box<dyn Error>> {
    let mut indexes = Vec::new();
    let mut repository = None;
    for argument in arguments {
        if argument.contains('/') {
            if repository.is_some() {
                return Err("only one OWNER/REPOSITORY may be provided".into());
            }
            RepositoryScope::parse(argument)?;
            repository = Some(argument.clone());
        } else {
            indexes.push(number(argument)?);
        }
    }
    if indexes.is_empty() {
        return Err("at least one issue index is required".into());
    }
    Ok((indexes, repository))
}

pub async fn run(
    command: &[String],
    selection: &Selection,
    client: &Client,
) -> Result<bool, Box<dyn Error>> {
    match command {
        [domain, action, arguments @ ..] if domain == "issue" && action == "list" => {
            let options = parse_issue_list(arguments)?;
            let scope = scope(selection, options.repository.as_deref())?;
            let issues = client
                .issues(
                    &scope,
                    &IssueQuery {
                        state: options.state,
                        labels: options.labels,
                        keyword: options.keyword,
                        kind: options.kind,
                        milestones: options.milestones,
                        from: options.from,
                        until: options.until,
                        author: options.author,
                        assignee: options.assignee,
                        mentions: options.mentions,
                        page: options.page,
                        limit: options.limit,
                    },
                )
                .await?;
            print_issues(&issues.items);
        }
        [domain, action, index] if domain == "issue" && action == "show" => {
            let scope = scope(selection, None)?;
            print_issue(&client.issue(&scope, number(index)?).await?);
        }
        [domain, action, index, repository] if domain == "issue" && action == "show" => {
            let scope = scope(selection, Some(repository))?;
            print_issue(&client.issue(&scope, number(index)?).await?);
        }
        [domain, action] if domain == "issue" && action == "create" => {
            create_issue(client, &scope(selection, None)?).await?;
        }
        [domain, action, repository] if domain == "issue" && action == "create" => {
            create_issue(client, &scope(selection, Some(repository))?).await?;
        }
        [domain, action, arguments @ ..] if domain == "issue" && action == "edit" => {
            let (indexes, repository) = issue_targets(arguments)?;
            edit_issues(client, &scope(selection, repository.as_deref())?, &indexes).await?;
        }
        [domain, action, arguments @ ..]
            if domain == "issue" && matches!(action.as_str(), "close" | "reopen") =>
        {
            let (indexes, repository) = issue_targets(arguments)?;
            let scope = scope(selection, repository.as_deref())?;
            set_issue_state(
                client,
                &scope,
                &indexes,
                if action == "close" { "closed" } else { "open" },
            )
            .await?;
        }
        [domain, action, index] if domain == "issue" && action == "delete" => {
            delete_issue(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "issue" && action == "delete" => {
            delete_issue(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action, index] if domain == "issue" && action == "comments" => {
            list_comments(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "issue" && action == "comments" => {
            list_comments(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action, index] if domain == "issue" && action == "comment" => {
            create_comment(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "issue" && action == "comment" => {
            create_comment(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action] if domain == "milestone" && action == "list" => {
            list_milestones(client, &scope(selection, None)?).await?;
        }
        [domain, action, repository] if domain == "milestone" && action == "list" => {
            list_milestones(client, &scope(selection, Some(repository))?).await?;
        }
        [domain, action, id] if domain == "milestone" && action == "show" => {
            show_milestone(client, &scope(selection, None)?, id).await?;
        }
        [domain, action, id, repository] if domain == "milestone" && action == "show" => {
            show_milestone(client, &scope(selection, Some(repository))?, id).await?;
        }
        [domain, action] if domain == "milestone" && action == "create" => {
            create_milestone(client, &scope(selection, None)?).await?;
        }
        [domain, action, repository] if domain == "milestone" && action == "create" => {
            create_milestone(client, &scope(selection, Some(repository))?).await?;
        }
        [domain, action, id] if domain == "milestone" && action == "edit" => {
            edit_milestone(client, &scope(selection, None)?, id).await?;
        }
        [domain, action, id, repository] if domain == "milestone" && action == "edit" => {
            edit_milestone(client, &scope(selection, Some(repository))?, id).await?;
        }
        [domain, action, id] if domain == "milestone" && action == "delete" => {
            delete_milestone(client, &scope(selection, None)?, id).await?;
        }
        [domain, action, id, repository] if domain == "milestone" && action == "delete" => {
            delete_milestone(client, &scope(selection, Some(repository))?, id).await?;
        }
        [domain, action] if domain == "pull" && action == "list" => {
            list_pulls(client, &scope(selection, None)?).await?;
        }
        [domain, action, repository] if domain == "pull" && action == "list" => {
            list_pulls(client, &scope(selection, Some(repository))?).await?;
        }
        [domain, action, index] if domain == "pull" && action == "show" => {
            show_pull(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "pull" && action == "show" => {
            show_pull(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action] if domain == "pull" && action == "create" => {
            create_pull(client, &scope(selection, None)?).await?;
        }
        [domain, action, repository] if domain == "pull" && action == "create" => {
            create_pull(client, &scope(selection, Some(repository))?).await?;
        }
        [domain, action, index] if domain == "pull" && action == "edit" => {
            edit_pull(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "pull" && action == "edit" => {
            edit_pull(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action, index] if domain == "pull" && action == "merge" => {
            merge_pull(client, &scope(selection, None)?, number(index)?).await?;
        }
        [domain, action, index, repository] if domain == "pull" && action == "merge" => {
            merge_pull(client, &scope(selection, Some(repository))?, number(index)?).await?;
        }
        [domain, action, index]
            if domain == "pull" && matches!(action.as_str(), "commits" | "files" | "reviews") =>
        {
            pull_details(client, &scope(selection, None)?, number(index)?, action).await?;
        }
        [domain, action, index, repository]
            if domain == "pull" && matches!(action.as_str(), "commits" | "files" | "reviews") =>
        {
            pull_details(
                client,
                &scope(selection, Some(repository))?,
                number(index)?,
                action,
            )
            .await?;
        }
        [domain, ..] if matches!(domain.as_str(), "issue" | "milestone" | "pull") => {
            return Ok(false);
        }
        _ => return Ok(false),
    }
    Ok(true)
}

fn scope(selection: &Selection, value: Option<&str>) -> Result<RepositoryScope, Box<dyn Error>> {
    match value {
        Some(value) => Ok(RepositoryScope::parse(value)?),
        None => selection.repository.clone().ok_or_else(|| {
            "cannot infer a repository; run inside one or pass OWNER/REPOSITORY".into()
        }),
    }
}

fn number(value: &str) -> Result<i64, Box<dyn Error>> {
    let number: i64 = value.parse()?;
    if number < 1 {
        return Err("index must be a positive integer".into());
    }
    Ok(number)
}

fn read_stdin() -> Result<String, Box<dyn Error>> {
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input)?;
    if input.trim().is_empty() {
        return Err("stdin must not be empty".into());
    }
    Ok(input)
}

fn read_yaml<T: DeserializeOwned>() -> Result<T, Box<dyn Error>> {
    parse_yaml(&read_stdin()?)
}

fn parse_yaml<T: DeserializeOwned>(input: &str) -> Result<T, Box<dyn Error>> {
    Ok(serde_yaml::from_str(input)?)
}

async fn create_issue(client: &Client, scope: &RepositoryScope) -> Result<(), Box<dyn Error>> {
    let input: CreateIssueInput = read_yaml()?;
    print_issue(
        &client
            .create_issue(
                scope,
                CreateIssue {
                    option: input.issue,
                    label_names: input.label_names,
                    milestone_name: input.milestone_name,
                },
            )
            .await?,
    );
    Ok(())
}

async fn edit_issues(
    client: &Client,
    scope: &RepositoryScope,
    indexes: &[i64],
) -> Result<(), Box<dyn Error>> {
    let input: EditIssueInput = read_yaml()?;
    for issue in client
        .edit_issues(
            scope,
            indexes,
            EditIssue {
                option: input.issue,
                replace_labels: None,
                add_labels: input.add_labels,
                remove_labels: input.remove_labels,
                add_assignees: input.add_assignees,
                milestone_name: input.milestone_name,
            },
        )
        .await?
    {
        print_issue(&issue);
    }
    Ok(())
}

async fn set_issue_state(
    client: &Client,
    scope: &RepositoryScope,
    indexes: &[i64],
    state: &str,
) -> Result<(), Box<dyn Error>> {
    for issue in client.set_issue_state(scope, indexes, state).await? {
        print_issue(&issue);
    }
    Ok(())
}

async fn delete_issue(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    client.delete_issue(scope, index).await?;
    println!("Deleted issue #{index}.");
    Ok(())
}

async fn list_comments(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    let comments = client.issue_comments(scope, index).await?;
    print_comments(&comments);
    Ok(())
}

async fn create_comment(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    let body = read_stdin()?.trim_end().to_owned();
    let comment = client.create_issue_comment(scope, index, body).await?;
    print_comments(&[comment]);
    Ok(())
}

async fn list_milestones(client: &Client, scope: &RepositoryScope) -> Result<(), Box<dyn Error>> {
    let milestones = client.milestones(scope).await?;
    print_milestones(&milestones);
    Ok(())
}

async fn show_milestone(
    client: &Client,
    scope: &RepositoryScope,
    id: &str,
) -> Result<(), Box<dyn Error>> {
    let milestone = client.milestone(scope, number(id)?).await?;
    print_milestone(&milestone);
    Ok(())
}

async fn create_milestone(client: &Client, scope: &RepositoryScope) -> Result<(), Box<dyn Error>> {
    let body: CreateMilestoneOption = read_yaml()?;
    let milestone = client.create_milestone(scope, body).await?;
    print_milestone(&milestone);
    Ok(())
}

async fn edit_milestone(
    client: &Client,
    scope: &RepositoryScope,
    id: &str,
) -> Result<(), Box<dyn Error>> {
    let milestone = client
        .edit_milestone(scope, id, read_yaml::<EditMilestoneOption>()?)
        .await?;
    print_milestone(&milestone);
    Ok(())
}

async fn delete_milestone(
    client: &Client,
    scope: &RepositoryScope,
    id: &str,
) -> Result<(), Box<dyn Error>> {
    client.delete_milestone(scope, id).await?;
    println!("Deleted milestone {id}.");
    Ok(())
}

async fn list_pulls(client: &Client, scope: &RepositoryScope) -> Result<(), Box<dyn Error>> {
    print_pulls(&client.repository_pulls(scope, "open", 1, 30).await?.items);
    Ok(())
}

async fn show_pull(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    let pull = client.pull(scope, index).await?;
    print_pull(&pull);
    Ok(())
}

async fn create_pull(client: &Client, scope: &RepositoryScope) -> Result<(), Box<dyn Error>> {
    let body: CreatePullRequestOption = read_yaml()?;
    let pull = client.create_pull(scope, body).await?;
    print_pull(&pull);
    Ok(())
}

async fn edit_pull(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    let pull = client
        .edit_pull(scope, index, read_yaml::<EditPullRequestOption>()?)
        .await?;
    print_pull(&pull);
    Ok(())
}

async fn merge_pull(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
) -> Result<(), Box<dyn Error>> {
    client
        .merge_pull(scope, index, read_yaml::<MergePullRequestOption>()?)
        .await?;
    println!("Merged pull request #{index}.");
    Ok(())
}

async fn pull_details(
    client: &Client,
    scope: &RepositoryScope,
    index: i64,
    action: &str,
) -> Result<(), Box<dyn Error>> {
    match action {
        "commits" => print_commits(&client.pull_commits(scope, index).await?),
        "files" => print_files(&client.pull_files(scope, index).await?),
        "reviews" => print_reviews(&client.pull_reviews(scope, index).await?),
        _ => unreachable!(),
    }
    Ok(())
}

fn print_issues(issues: &[Issue]) {
    print_table(
        &[
            ("INDEX", 8),
            ("STATE", 10),
            ("TITLE", 60),
            ("MILESTONE", 30),
            ("LABELS", 30),
        ],
        issues
            .iter()
            .map(|issue| {
                vec![
                    issue.number.unwrap_or_default().to_string(),
                    issue.state.as_deref().unwrap_or("unknown").into(),
                    one_line(issue.title.as_deref().unwrap_or("")).into(),
                    issue
                        .milestone
                        .as_deref()
                        .and_then(|milestone| milestone.title.as_deref())
                        .unwrap_or("-")
                        .into(),
                    issue_labels(issue),
                ]
            })
            .collect(),
    );
}

fn print_issue(issue: &Issue) {
    println!(
        "#{} [{}] {}",
        issue.number.unwrap_or_default(),
        issue.state.as_deref().unwrap_or("unknown"),
        issue.title.as_deref().unwrap_or("")
    );
    field("url", issue.html_url.as_deref());
    field(
        "author",
        issue.user.as_deref().and_then(|user| user.login.as_deref()),
    );
    let milestone = issue
        .milestone
        .as_deref()
        .and_then(|milestone| milestone.title.as_deref());
    field("milestone", milestone);
    let labels = issue_labels(issue);
    field("labels", (!labels.is_empty()).then_some(labels.as_str()));
    let assignees = issue
        .assignees
        .as_deref()
        .unwrap_or_default()
        .iter()
        .filter_map(|user| user.login.as_deref())
        .collect::<Vec<_>>()
        .join(",");
    field(
        "assignees",
        (!assignees.is_empty()).then_some(assignees.as_str()),
    );
    field("due", issue.due_date.as_deref());
    field("created", issue.created_at.as_deref());
    field("updated", issue.updated_at.as_deref());
    println!("comments: {}", issue.comments.unwrap_or_default());
    body(issue.body.as_deref());
}

fn issue_labels(issue: &Issue) -> String {
    issue
        .labels
        .as_deref()
        .unwrap_or_default()
        .iter()
        .filter_map(|label| label.name.as_deref())
        .collect::<Vec<_>>()
        .join(",")
}

fn print_comments(comments: &[Comment]) {
    for comment in comments {
        println!(
            "{} · {}",
            comment
                .user
                .as_deref()
                .and_then(|user| user.login.as_deref())
                .unwrap_or("unknown"),
            comment.created_at.as_deref().unwrap_or("-")
        );
        body(comment.body.as_deref());
    }
}

fn print_milestones(milestones: &[Milestone]) {
    print_table(
        &[
            ("ID", 8),
            ("STATE", 10),
            ("TITLE", 60),
            ("DUE", 25),
            ("OPEN/CLOSED", 12),
        ],
        milestones
            .iter()
            .map(|milestone| {
                vec![
                    milestone.id.unwrap_or_default().to_string(),
                    milestone.state.as_deref().unwrap_or("unknown").into(),
                    one_line(milestone.title.as_deref().unwrap_or("")).into(),
                    milestone.due_on.as_deref().unwrap_or("-").into(),
                    format!(
                        "{}/{}",
                        milestone.open_issues.unwrap_or_default(),
                        milestone.closed_issues.unwrap_or_default()
                    ),
                ]
            })
            .collect(),
    );
}

fn print_milestone(milestone: &Milestone) {
    println!(
        "{} [{}] {}",
        milestone.id.unwrap_or_default(),
        milestone.state.as_deref().unwrap_or("unknown"),
        milestone.title.as_deref().unwrap_or("")
    );
    field("due", milestone.due_on.as_deref());
    println!(
        "issues: {} open, {} closed",
        milestone.open_issues.unwrap_or_default(),
        milestone.closed_issues.unwrap_or_default()
    );
    body(milestone.description.as_deref());
}

fn print_pulls(pulls: &[PullRequest]) {
    print_table(
        &[("INDEX", 8), ("STATE", 10), ("TITLE", 70), ("UPDATED", 25)],
        pulls
            .iter()
            .map(|pull| {
                vec![
                    pull.number.unwrap_or_default().to_string(),
                    pull.state.as_deref().unwrap_or("unknown").into(),
                    one_line(pull.title.as_deref().unwrap_or("")).into(),
                    pull.updated_at.as_deref().unwrap_or("-").into(),
                ]
            })
            .collect(),
    );
}

fn print_pull(pull: &PullRequest) {
    println!(
        "#{} [{}] {}",
        pull.number.unwrap_or_default(),
        pull_state(pull),
        pull.title.as_deref().unwrap_or("")
    );
    field("url", pull.html_url.as_deref());
    field(
        "author",
        pull.user.as_deref().and_then(|user| user.login.as_deref()),
    );
    field("updated", pull.updated_at.as_deref());
    println!("mergeable: {}", pull.mergeable.unwrap_or(false));
    body(pull.body.as_deref());
}

fn print_commits(commits: &[Commit]) {
    print_table(
        &[("SHA", 40), ("MESSAGE", 80)],
        commits
            .iter()
            .map(|commit| {
                vec![
                    commit.sha.as_deref().unwrap_or("unknown").into(),
                    one_line(
                        commit
                            .commit
                            .as_deref()
                            .and_then(|commit| commit.message.as_deref())
                            .unwrap_or(""),
                    )
                    .into(),
                ]
            })
            .collect(),
    );
}

fn print_files(files: &[ChangedFile]) {
    print_table(
        &[("STATUS", 12), ("CHANGES", 10), ("FILE", 90)],
        files
            .iter()
            .map(|file| {
                vec![
                    file.status.as_deref().unwrap_or("unknown").into(),
                    file.changes.unwrap_or_default().to_string(),
                    file.filename.as_deref().unwrap_or("").into(),
                ]
            })
            .collect(),
    );
}

fn print_reviews(reviews: &[PullReview]) {
    print_table(
        &[
            ("ID", 12),
            ("STATE", 20),
            ("REVIEWER", 25),
            ("SUBMITTED", 25),
        ],
        reviews
            .iter()
            .map(|review| {
                vec![
                    review.id.unwrap_or_default().to_string(),
                    review.state.as_deref().unwrap_or("unknown").into(),
                    review
                        .user
                        .as_deref()
                        .and_then(|user| user.login.as_deref())
                        .unwrap_or("unknown")
                        .into(),
                    review.submitted_at.as_deref().unwrap_or("-").into(),
                ]
            })
            .collect(),
    );
}

fn field(name: &str, value: Option<&str>) {
    if let Some(value) = value.filter(|value| !value.is_empty()) {
        println!("{name}: {value}");
    }
}

fn body(value: Option<&str>) {
    if let Some(value) = value.filter(|value| !value.is_empty()) {
        println!("\n{value}");
    }
}

fn one_line(value: &str) -> &str {
    value.lines().next().unwrap_or_default()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_typed_yaml_and_rejects_bad_indexes() {
        let issue: CreateIssueInput = parse_yaml(
            "title: Fix it\nbody: Details\nlabel_names: [bug]\nmilestone_name: Version 1\n",
        )
        .unwrap();

        assert_eq!(issue.issue.title, "Fix it");
        assert_eq!(issue.issue.body.as_deref(), Some("Details"));
        assert_eq!(issue.label_names, ["bug"]);
        assert_eq!(issue.milestone_name.as_deref(), Some("Version 1"));
        let edit: EditIssueInput = parse_yaml(
            "title: Updated\nadd_labels: [critical]\nremove_labels: [bug]\nadd_assignees: [alice]\n",
        )
        .unwrap();
        assert_eq!(edit.issue.title.as_deref(), Some("Updated"));
        assert_eq!(edit.add_labels, ["critical"]);
        assert_eq!(edit.remove_labels, ["bug"]);
        assert_eq!(edit.add_assignees, ["alice"]);
        assert!(number("0").is_err());
        assert!(number("7").is_ok());
    }

    #[test]
    fn parses_issue_workflow_filters_and_bulk_state_targets() {
        let options = parse_issue_list(
            &[
                "hugo/Gotcha",
                "--state",
                "all",
                "--milestones",
                "first feature complete release",
                "-L",
                "bug,critical",
                "--page",
                "2",
                "--limit",
                "50",
            ]
            .map(str::to_owned),
        )
        .unwrap();
        assert_eq!(options.repository.as_deref(), Some("hugo/Gotcha"));
        assert_eq!(options.state, "all");
        assert_eq!(
            options.milestones.as_deref(),
            Some("first feature complete release")
        );
        assert_eq!(options.labels.as_deref(), Some("bug,critical"));
        assert_eq!((options.page, options.limit), (2, 50));

        let (indexes, repository) =
            issue_targets(&["4", "16", "hugo/Gotcha"].map(str::to_owned)).unwrap();
        assert_eq!(indexes, [4, 16]);
        assert_eq!(repository.as_deref(), Some("hugo/Gotcha"));
        assert!(parse_issue_list(&["--state".into(), "invalid".into()]).is_err());
        assert!(issue_targets(&[]).is_err());
    }
}