//! Command-line interface for the makima CLI.

pub mod config;
pub mod contract;
pub mod daemon;
pub mod red_team;
pub mod server;
pub mod supervisor;
pub mod view;

use clap::{Args, Parser, Subcommand};
use uuid::Uuid;

pub use config::CliConfig;
pub use contract::ContractArgs;
pub use contract::{PauseArgs, ResumeArgs, AdvanceArgs, RestartSupervisorArgs, ShowArgs, HealthArgs};
pub use daemon::DaemonArgs;
pub use red_team::handle_notify;
pub use server::ServerArgs;
pub use supervisor::SupervisorArgs;
pub use view::ViewArgs;

/// Makima - unified CLI for server, daemon, and task management.
#[derive(Parser, Debug)]
#[command(name = "makima")]
#[command(version, about = "Makima CLI - server, daemon, and task management", long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand, Debug)]
pub enum Commands {
    /// Run the makima server
    Server(ServerArgs),

    /// Run the daemon (connect to server, manage tasks)
    Daemon(DaemonArgs),

    /// Supervisor commands for contract orchestration
    #[command(subcommand)]
    Supervisor(SupervisorCommand),

    /// Contract commands for task-contract interaction
    #[command(subcommand)]
    Contract(ContractCommand),

    /// Interactive TUI browser for contracts and tasks
    ///
    /// Provides a drill-down interface for browsing contracts, viewing their
    /// tasks, and streaming real-time task output.
    ///
    /// Keyboard shortcuts:
    ///   ↑/k: Move up    ↓/j: Move down    Enter/l: Drill in
    ///   Esc/h: Go back  /: Search         q: Quit
    ///   e: Edit         d: Delete         c: cd to worktree
    ///   n: New contract
    View(ViewArgs),

    /// Configure CLI settings (API key, server URL)
    ///
    /// Saves configuration to ~/.makima/config.toml for use by CLI commands.
    #[command(subcommand)]
    Config(ConfigCommand),

    /// Red team commands for adversarial monitoring
    #[command(name = "red-team", subcommand)]
    RedTeam(RedTeamCommand),

    /// Contract management helper commands
    ///
    /// User-facing commands for managing contracts (pause, resume, show, etc.)
    #[command(subcommand)]
    Contracts(ContractsCommand),
}

/// Config subcommands for CLI configuration.
#[derive(Subcommand, Debug)]
pub enum ConfigCommand {
    /// Set the API key
    ///
    /// Saves the API key to ~/.makima/config.toml
    SetKey(config::SetKeyArgs),

    /// Set the API URL
    ///
    /// Saves the API URL to ~/.makima/config.toml
    SetUrl(config::SetUrlArgs),

    /// Show current configuration
    Show,

    /// Show the config file path
    Path,
}

/// Supervisor subcommands for contract orchestration.
#[derive(Subcommand, Debug)]
pub enum SupervisorCommand {
    /// List all tasks in the contract
    Tasks(SupervisorArgs),

    /// Get the task tree structure
    Tree(SupervisorArgs),

    /// Create and start a new task
    Spawn(supervisor::SpawnArgs),

    /// Wait for a task to complete
    Wait(supervisor::WaitArgs),

    /// Read a file from a task's worktree
    ReadFile(supervisor::ReadFileArgs),

    /// Create a git branch
    Branch(supervisor::BranchArgs),

    /// Merge a task's changes to a branch
    Merge(supervisor::MergeArgs),

    /// Create a pull request
    Pr(supervisor::PrArgs),

    /// View task diff
    Diff(supervisor::DiffArgs),

    /// Create a checkpoint
    Checkpoint(supervisor::CheckpointArgs),

    /// List checkpoints
    Checkpoints(SupervisorArgs),

    /// Get contract status
    Status(SupervisorArgs),

    /// Advance the contract to the next phase
    AdvancePhase(supervisor::AdvancePhaseArgs),

    /// Ask a question and wait for user feedback
    Ask(supervisor::AskArgs),

    /// Get individual task details
    Task(supervisor::GetTaskArgs),

    /// Get task output/claude log
    Output(supervisor::GetTaskOutputArgs),

    /// View task conversation history
    TaskHistory(supervisor::TaskHistoryArgs),

    /// List task checkpoints (with optional diff)
    TaskCheckpoints(supervisor::TaskCheckpointsArgs),

    /// Resume supervisor after interruption
    Resume(supervisor::ResumeArgs),

    /// Resume task from checkpoint
    TaskResumeFrom(supervisor::TaskResumeFromArgs),

    /// Rewind task code to checkpoint
    TaskRewind(supervisor::TaskRewindArgs),

    /// Fork task from historical point
    TaskFork(supervisor::TaskForkArgs),

    /// Rewind supervisor conversation
    RewindConversation(supervisor::ConversationRewindArgs),

    /// Mark the contract as complete and stop the supervisor
    Complete(supervisor::CompleteArgs),

    /// Resume a completed contract (reactivate it)
    ResumeContract(supervisor::ResumeContractArgs),

    /// Mark a deliverable as complete
    MarkDeliverable(supervisor::MarkDeliverableArgs),
}

/// Contract subcommands for task-contract interaction.
#[derive(Subcommand, Debug)]
pub enum ContractCommand {
    /// Get contract status
    Status(ContractArgs),

    /// Get the phase checklist
    Checklist(ContractArgs),

    /// Get contract goals
    Goals(ContractArgs),

    /// List contract files
    Files(ContractArgs),

    /// Get a specific file's content
    File(contract::FileArgs),

    /// Report progress on the contract
    Report(contract::ReportArgs),

    /// Get suggested next action
    SuggestAction(ContractArgs),

    /// Get completion recommendation
    CompletionAction(contract::CompletionActionArgs),

    /// Update a file (reads content from stdin)
    UpdateFile(contract::UpdateFileArgs),

    /// Create a new file (reads content from stdin)
    CreateFile(contract::CreateFileArgs),
}

/// Red team subcommands for adversarial monitoring.
#[derive(Subcommand, Debug)]
pub enum RedTeamCommand {
    /// Send a notification to the supervisor about a detected issue.
    /// Only available to red team tasks.
    Notify(RedTeamNotifyArgs),
}

/// Contract management helper subcommands.
#[derive(Subcommand, Debug)]
pub enum ContractsCommand {
    /// Pause a contract
    ///
    /// Sets the contract status to paused, optionally with a reason.
    /// The supervisor will be stopped and tasks will not be picked up.
    Pause(contract::PauseArgs),

    /// Resume a paused contract
    ///
    /// Sets the contract status back to active and restarts the supervisor.
    Resume(contract::ResumeArgs),

    /// Manually advance a contract to a specific phase
    ///
    /// Use --force to skip deliverable validation.
    Advance(contract::AdvanceArgs),

    /// Restart the supervisor for a contract
    ///
    /// Useful when the supervisor is stuck or needs to be refreshed.
    RestartSupervisor(contract::RestartSupervisorArgs),

    /// Show detailed contract information
    ///
    /// Use --verbose for all details including tasks and files.
    Show(contract::ShowArgs),

    /// Check contract and supervisor health
    ///
    /// Returns health status including supervisor state, task counts, and staleness.
    Health(contract::HealthArgs),
}

/// Arguments for red-team notify command.
#[derive(Args, Debug)]
pub struct RedTeamNotifyArgs {
    /// API URL
    #[arg(long, env = "MAKIMA_API_URL", default_value = "https://api.makima.jp")]
    pub api_url: String,

    /// API key for authentication
    #[arg(long, env = "MAKIMA_API_KEY")]
    pub api_key: String,

    /// Current task ID (must be a red team task)
    #[arg(long, env = "MAKIMA_TASK_ID")]
    pub task_id: Uuid,

    /// Contract ID
    #[arg(long, env = "MAKIMA_CONTRACT_ID")]
    pub contract_id: Uuid,

    /// The notification message
    #[arg(index = 1)]
    pub message: String,

    /// Severity level: low, medium, high, critical
    #[arg(long, default_value = "medium")]
    pub severity: String,

    /// Related task ID (optional)
    #[arg(long)]
    pub task: Option<Uuid>,

    /// Related file path (optional)
    #[arg(long)]
    pub file: Option<String>,

    /// Additional context (optional)
    #[arg(long)]
    pub context: Option<String>,
}

impl Cli {
    /// Parse command-line arguments
    pub fn parse_args() -> Self {
        Self::parse()
    }
}