pub mod commands;
pub mod progress;

use clap::{Parser, Subcommand};
use std::io::IsTerminal;

#[derive(Parser)]
#[command(name = "lore")]
#[command(version, about = "Local GitLab data management with semantic search", long_about = None)]
#[command(subcommand_required = false)]
pub struct Cli {
    /// Path to config file
    #[arg(short = 'c', long, global = true, help = "Path to config file")]
    pub config: Option<String>,

    /// Machine-readable JSON output (auto-enabled when piped)
    #[arg(
        long,
        global = true,
        env = "LORE_ROBOT",
        help = "Machine-readable JSON output (auto-enabled when piped)"
    )]
    pub robot: bool,

    /// JSON output (global shorthand)
    #[arg(
        short = 'J',
        long = "json",
        global = true,
        help = "JSON output (global shorthand)"
    )]
    pub json: bool,

    /// Color output: auto (default), always, or never
    #[arg(long, global = true, value_parser = ["auto", "always", "never"], default_value = "auto", help = "Color output: auto (default), always, or never")]
    pub color: String,

    /// Suppress non-essential output
    #[arg(
        short = 'q',
        long,
        global = true,
        overrides_with = "no_quiet",
        help = "Suppress non-essential output"
    )]
    pub quiet: bool,

    #[arg(
        long = "no-quiet",
        global = true,
        hide = true,
        overrides_with = "quiet"
    )]
    pub no_quiet: bool,

    /// Increase log verbosity (-v, -vv, -vvv)
    #[arg(short = 'v', long = "verbose", action = clap::ArgAction::Count, global = true, help = "Increase log verbosity (-v, -vv, -vvv)")]
    pub verbose: u8,

    /// Log format for stderr output: text (default) or json
    #[arg(long = "log-format", global = true, value_parser = ["text", "json"], default_value = "text", help = "Log format for stderr output: text (default) or json")]
    pub log_format: String,

    #[command(subcommand)]
    pub command: Option<Commands>,
}

impl Cli {
    pub fn is_robot_mode(&self) -> bool {
        self.robot || self.json || !std::io::stdout().is_terminal()
    }

    /// Detect robot mode from environment before parsing succeeds.
    /// Used for structured error output when clap parsing fails.
    pub fn detect_robot_mode_from_env() -> bool {
        let args: Vec<String> = std::env::args().collect();
        args.iter()
            .any(|a| a == "--robot" || a == "-J" || a == "--json")
            || std::env::var("LORE_ROBOT").is_ok()
            || !std::io::stdout().is_terminal()
    }
}

#[derive(Subcommand)]
#[allow(clippy::large_enum_variant)]
pub enum Commands {
    /// List or show issues
    Issues(IssuesArgs),

    /// List or show merge requests
    Mrs(MrsArgs),

    /// Ingest data from GitLab
    Ingest(IngestArgs),

    /// Count entities in local database
    Count(CountArgs),

    /// Show sync state
    Status,

    /// Verify GitLab authentication
    Auth,

    /// Check environment health
    Doctor,

    /// Show version information
    Version,

    /// Initialize configuration and database
    Init {
        /// Skip overwrite confirmation
        #[arg(short = 'f', long)]
        force: bool,

        /// Fail if prompts would be shown
        #[arg(long)]
        non_interactive: bool,

        /// GitLab base URL (required in robot mode)
        #[arg(long)]
        gitlab_url: Option<String>,

        /// Environment variable name holding GitLab token (required in robot mode)
        #[arg(long)]
        token_env_var: Option<String>,

        /// Comma-separated project paths (required in robot mode)
        #[arg(long)]
        projects: Option<String>,
    },

    #[command(hide = true)]
    Backup,

    #[command(hide = true)]
    Reset {
        #[arg(short = 'y', long)]
        yes: bool,
    },

    /// Search indexed documents
    Search(SearchArgs),

    /// Show document and index statistics
    Stats(StatsArgs),

    /// Generate searchable documents from ingested data
    #[command(name = "generate-docs")]
    GenerateDocs(GenerateDocsArgs),

    /// Generate vector embeddings for documents via Ollama
    Embed(EmbedArgs),

    /// Run full sync pipeline: ingest -> generate-docs -> embed
    Sync(SyncArgs),

    /// Run pending database migrations
    Migrate,

    /// Quick health check: config, database, schema version
    Health,

    /// Machine-readable command manifest for agent self-discovery
    #[command(name = "robot-docs")]
    RobotDocs,

    /// Generate shell completions
    #[command(long_about = "Generate shell completions for lore.\n\n\
        Installation:\n  \
        bash:  lore completions bash > ~/.local/share/bash-completion/completions/lore\n  \
        zsh:   lore completions zsh > ~/.zfunc/_lore && echo 'fpath+=~/.zfunc' >> ~/.zshrc\n  \
        fish:  lore completions fish > ~/.config/fish/completions/lore.fish\n  \
        pwsh:  lore completions powershell >> $PROFILE")]
    Completions {
        /// Shell to generate completions for
        #[arg(value_parser = ["bash", "zsh", "fish", "powershell"])]
        shell: String,
    },

    /// Show a chronological timeline of events matching a query
    Timeline(TimelineArgs),

    #[command(hide = true)]
    List {
        #[arg(value_parser = ["issues", "mrs"])]
        entity: String,

        #[arg(long, default_value = "50")]
        limit: usize,
        #[arg(long)]
        project: Option<String>,
        #[arg(long)]
        state: Option<String>,
        #[arg(long)]
        author: Option<String>,
        #[arg(long)]
        assignee: Option<String>,
        #[arg(long)]
        label: Option<Vec<String>>,
        #[arg(long)]
        milestone: Option<String>,
        #[arg(long)]
        since: Option<String>,
        #[arg(long)]
        due_before: Option<String>,
        #[arg(long)]
        has_due_date: bool,
        #[arg(long, value_parser = ["updated", "created", "iid"], default_value = "updated")]
        sort: String,
        #[arg(long, value_parser = ["desc", "asc"], default_value = "desc")]
        order: String,
        #[arg(long)]
        open: bool,
        #[arg(long, conflicts_with = "no_draft")]
        draft: bool,
        #[arg(long, conflicts_with = "draft")]
        no_draft: bool,
        #[arg(long)]
        reviewer: Option<String>,
        #[arg(long)]
        target_branch: Option<String>,
        #[arg(long)]
        source_branch: Option<String>,
    },

    #[command(hide = true)]
    Show {
        #[arg(value_parser = ["issue", "mr"])]
        entity: String,

        iid: i64,

        #[arg(long)]
        project: Option<String>,
    },

    #[command(hide = true, name = "auth-test")]
    AuthTest,

    #[command(hide = true, name = "sync-status")]
    SyncStatus,
}

#[derive(Parser)]
pub struct IssuesArgs {
    /// Issue IID (omit to list, provide to show details)
    pub iid: Option<i64>,

    /// Maximum results
    #[arg(
        short = 'n',
        long = "limit",
        default_value = "50",
        help_heading = "Output"
    )]
    pub limit: usize,

    /// Select output fields (comma-separated: iid,title,state,author,labels,updated)
    #[arg(long, help_heading = "Output", value_delimiter = ',')]
    pub fields: Option<Vec<String>>,

    /// Filter by state (opened, closed, all)
    #[arg(short = 's', long, help_heading = "Filters")]
    pub state: Option<String>,

    /// Filter by project path
    #[arg(short = 'p', long, help_heading = "Filters")]
    pub project: Option<String>,

    /// Filter by author username
    #[arg(short = 'a', long, help_heading = "Filters")]
    pub author: Option<String>,

    /// Filter by assignee username
    #[arg(short = 'A', long, help_heading = "Filters")]
    pub assignee: Option<String>,

    /// Filter by label (repeatable, AND logic)
    #[arg(short = 'l', long, help_heading = "Filters")]
    pub label: Option<Vec<String>>,

    /// Filter by milestone title
    #[arg(short = 'm', long, help_heading = "Filters")]
    pub milestone: Option<String>,

    /// Filter by time (7d, 2w, 1m, or YYYY-MM-DD)
    #[arg(long, help_heading = "Filters")]
    pub since: Option<String>,

    /// Filter by due date (before this date, YYYY-MM-DD)
    #[arg(long = "due-before", help_heading = "Filters")]
    pub due_before: Option<String>,

    /// Show only issues with a due date
    #[arg(
        long = "has-due",
        help_heading = "Filters",
        overrides_with = "no_has_due"
    )]
    pub has_due: bool,

    #[arg(long = "no-has-due", hide = true, overrides_with = "has_due")]
    pub no_has_due: bool,

    /// Sort field (updated, created, iid)
    #[arg(long, value_parser = ["updated", "created", "iid"], default_value = "updated", help_heading = "Sorting")]
    pub sort: String,

    /// Sort ascending (default: descending)
    #[arg(long, help_heading = "Sorting", overrides_with = "no_asc")]
    pub asc: bool,

    #[arg(long = "no-asc", hide = true, overrides_with = "asc")]
    pub no_asc: bool,

    /// Open first matching item in browser
    #[arg(
        short = 'o',
        long,
        help_heading = "Actions",
        overrides_with = "no_open"
    )]
    pub open: bool,

    #[arg(long = "no-open", hide = true, overrides_with = "open")]
    pub no_open: bool,
}

#[derive(Parser)]
pub struct MrsArgs {
    /// MR IID (omit to list, provide to show details)
    pub iid: Option<i64>,

    /// Maximum results
    #[arg(
        short = 'n',
        long = "limit",
        default_value = "50",
        help_heading = "Output"
    )]
    pub limit: usize,

    /// Select output fields (comma-separated: iid,title,state,author,labels,updated)
    #[arg(long, help_heading = "Output", value_delimiter = ',')]
    pub fields: Option<Vec<String>>,

    /// Filter by state (opened, merged, closed, locked, all)
    #[arg(short = 's', long, help_heading = "Filters")]
    pub state: Option<String>,

    /// Filter by project path
    #[arg(short = 'p', long, help_heading = "Filters")]
    pub project: Option<String>,

    /// Filter by author username
    #[arg(short = 'a', long, help_heading = "Filters")]
    pub author: Option<String>,

    /// Filter by assignee username
    #[arg(short = 'A', long, help_heading = "Filters")]
    pub assignee: Option<String>,

    /// Filter by reviewer username
    #[arg(short = 'r', long, help_heading = "Filters")]
    pub reviewer: Option<String>,

    /// Filter by label (repeatable, AND logic)
    #[arg(short = 'l', long, help_heading = "Filters")]
    pub label: Option<Vec<String>>,

    /// Filter by time (7d, 2w, 1m, or YYYY-MM-DD)
    #[arg(long, help_heading = "Filters")]
    pub since: Option<String>,

    /// Show only draft MRs
    #[arg(
        short = 'd',
        long,
        conflicts_with = "no_draft",
        help_heading = "Filters"
    )]
    pub draft: bool,

    /// Exclude draft MRs
    #[arg(
        short = 'D',
        long = "no-draft",
        conflicts_with = "draft",
        help_heading = "Filters"
    )]
    pub no_draft: bool,

    /// Filter by target branch
    #[arg(long, help_heading = "Filters")]
    pub target: Option<String>,

    /// Filter by source branch
    #[arg(long, help_heading = "Filters")]
    pub source: Option<String>,

    /// Sort field (updated, created, iid)
    #[arg(long, value_parser = ["updated", "created", "iid"], default_value = "updated", help_heading = "Sorting")]
    pub sort: String,

    /// Sort ascending (default: descending)
    #[arg(long, help_heading = "Sorting", overrides_with = "no_asc")]
    pub asc: bool,

    #[arg(long = "no-asc", hide = true, overrides_with = "asc")]
    pub no_asc: bool,

    /// Open first matching item in browser
    #[arg(
        short = 'o',
        long,
        help_heading = "Actions",
        overrides_with = "no_open"
    )]
    pub open: bool,

    #[arg(long = "no-open", hide = true, overrides_with = "open")]
    pub no_open: bool,
}

#[derive(Parser)]
pub struct IngestArgs {
    /// Entity to ingest (issues, mrs). Omit to ingest everything
    #[arg(value_parser = ["issues", "mrs"])]
    pub entity: Option<String>,

    /// Filter to single project
    #[arg(short = 'p', long)]
    pub project: Option<String>,

    /// Override stale sync lock
    #[arg(short = 'f', long, overrides_with = "no_force")]
    pub force: bool,

    #[arg(long = "no-force", hide = true, overrides_with = "force")]
    pub no_force: bool,

    /// Full re-sync: reset cursors and fetch all data from scratch
    #[arg(long, overrides_with = "no_full")]
    pub full: bool,

    #[arg(long = "no-full", hide = true, overrides_with = "full")]
    pub no_full: bool,

    /// Preview what would be synced without making changes
    #[arg(long, overrides_with = "no_dry_run")]
    pub dry_run: bool,

    #[arg(long = "no-dry-run", hide = true, overrides_with = "dry_run")]
    pub no_dry_run: bool,
}

#[derive(Parser)]
pub struct StatsArgs {
    /// Run integrity checks
    #[arg(long, overrides_with = "no_check")]
    pub check: bool,

    #[arg(long = "no-check", hide = true, overrides_with = "check")]
    pub no_check: bool,

    /// Repair integrity issues (auto-enables --check)
    #[arg(long)]
    pub repair: bool,

    /// Preview what would be repaired without making changes (requires --repair)
    #[arg(long, overrides_with = "no_dry_run")]
    pub dry_run: bool,

    #[arg(long = "no-dry-run", hide = true, overrides_with = "dry_run")]
    pub no_dry_run: bool,
}

#[derive(Parser)]
pub struct SearchArgs {
    /// Search query string
    pub query: String,

    /// Search mode (lexical, hybrid, semantic)
    #[arg(long, default_value = "hybrid", value_parser = ["lexical", "hybrid", "semantic"], help_heading = "Output")]
    pub mode: String,

    /// Filter by source type (issue, mr, discussion)
    #[arg(long = "type", value_name = "TYPE", value_parser = ["issue", "mr", "discussion"], help_heading = "Filters")]
    pub source_type: Option<String>,

    /// Filter by author username
    #[arg(long, help_heading = "Filters")]
    pub author: Option<String>,

    /// Filter by project path
    #[arg(short = 'p', long, help_heading = "Filters")]
    pub project: Option<String>,

    /// Filter by label (repeatable, AND logic)
    #[arg(long, action = clap::ArgAction::Append, help_heading = "Filters")]
    pub label: Vec<String>,

    /// Filter by file path (trailing / for prefix match)
    #[arg(long, help_heading = "Filters")]
    pub path: Option<String>,

    /// Filter by created after (7d, 2w, or YYYY-MM-DD)
    #[arg(long, help_heading = "Filters")]
    pub after: Option<String>,

    /// Filter by updated after (7d, 2w, or YYYY-MM-DD)
    #[arg(long = "updated-after", help_heading = "Filters")]
    pub updated_after: Option<String>,

    /// Maximum results (default 20, max 100)
    #[arg(
        short = 'n',
        long = "limit",
        default_value = "20",
        help_heading = "Output"
    )]
    pub limit: usize,

    /// Show ranking explanation per result
    #[arg(long, help_heading = "Output", overrides_with = "no_explain")]
    pub explain: bool,

    #[arg(long = "no-explain", hide = true, overrides_with = "explain")]
    pub no_explain: bool,

    /// FTS query mode: safe (default) or raw
    #[arg(long = "fts-mode", default_value = "safe", value_parser = ["safe", "raw"], help_heading = "Output")]
    pub fts_mode: String,
}

#[derive(Parser)]
pub struct GenerateDocsArgs {
    /// Full rebuild: seed all entities into dirty queue, then drain
    #[arg(long)]
    pub full: bool,

    /// Filter to single project
    #[arg(short = 'p', long)]
    pub project: Option<String>,
}

#[derive(Parser)]
pub struct SyncArgs {
    /// Reset cursors, fetch everything
    #[arg(long, overrides_with = "no_full")]
    pub full: bool,

    #[arg(long = "no-full", hide = true, overrides_with = "full")]
    pub no_full: bool,

    /// Override stale lock
    #[arg(long, overrides_with = "no_force")]
    pub force: bool,

    #[arg(long = "no-force", hide = true, overrides_with = "force")]
    pub no_force: bool,

    /// Skip embedding step
    #[arg(long)]
    pub no_embed: bool,

    /// Skip document regeneration
    #[arg(long)]
    pub no_docs: bool,

    /// Skip resource event fetching (overrides config)
    #[arg(long = "no-events")]
    pub no_events: bool,

    /// Preview what would be synced without making changes
    #[arg(long, overrides_with = "no_dry_run")]
    pub dry_run: bool,

    #[arg(long = "no-dry-run", hide = true, overrides_with = "dry_run")]
    pub no_dry_run: bool,
}

#[derive(Parser)]
pub struct EmbedArgs {
    /// Re-embed all documents (clears existing embeddings first)
    #[arg(long, overrides_with = "no_full")]
    pub full: bool,

    #[arg(long = "no-full", hide = true, overrides_with = "full")]
    pub no_full: bool,

    /// Retry previously failed embeddings
    #[arg(long, overrides_with = "no_retry_failed")]
    pub retry_failed: bool,

    #[arg(long = "no-retry-failed", hide = true, overrides_with = "retry_failed")]
    pub no_retry_failed: bool,
}

#[derive(Parser)]
pub struct TimelineArgs {
    /// Search query (keywords to find in issues, MRs, and discussions)
    pub query: String,

    /// Scope to a specific project (fuzzy match)
    #[arg(short = 'p', long, help_heading = "Filters")]
    pub project: Option<String>,

    /// Only show events after this date (e.g. "6m", "2w", "2024-01-01")
    #[arg(long, help_heading = "Filters")]
    pub since: Option<String>,

    /// Cross-reference expansion depth (0 = no expansion)
    #[arg(long, default_value = "1", help_heading = "Expansion")]
    pub depth: u32,

    /// Also follow 'mentioned' edges during expansion (high fan-out)
    #[arg(long = "expand-mentions", help_heading = "Expansion")]
    pub expand_mentions: bool,

    /// Maximum number of events to display
    #[arg(
        short = 'n',
        long = "limit",
        default_value = "100",
        help_heading = "Output"
    )]
    pub limit: usize,

    /// Maximum seed entities from search
    #[arg(long = "max-seeds", default_value = "10", help_heading = "Expansion")]
    pub max_seeds: usize,

    /// Maximum expanded entities via cross-references
    #[arg(
        long = "max-entities",
        default_value = "50",
        help_heading = "Expansion"
    )]
    pub max_entities: usize,

    /// Maximum evidence notes included
    #[arg(
        long = "max-evidence",
        default_value = "10",
        help_heading = "Expansion"
    )]
    pub max_evidence: usize,
}

#[derive(Parser)]
pub struct CountArgs {
    /// Entity type to count (issues, mrs, discussions, notes, events)
    #[arg(value_parser = ["issues", "mrs", "discussions", "notes", "events"])]
    pub entity: String,

    /// Parent type filter: issue or mr (for discussions/notes)
    #[arg(short = 'f', long = "for", value_parser = ["issue", "mr"])]
    pub for_entity: Option<String>,
}