framesmith-cli 0.1.0

use std::path::PathBuf;

use clap::{Parser, Subcommand, ValueEnum};
use clap_complete::Shell;

// ---------------------------------------------------------------------------
// Hostless CLI — for commands that don't need a TV host
// ---------------------------------------------------------------------------

#[derive(Parser)]
#[command(
    name = "framesmith",
    version,
    about = "CLI util for controlling Samsung Frame TVs"
)]
pub struct HostlessCli {
    #[command(subcommand)]
    pub command: HostlessCommand,

    /// Emit all output as JSON
    #[arg(long, global = true)]
    pub json: bool,

    /// Enable verbose/debug output
    #[arg(short, long, global = true)]
    pub verbose: bool,
}

#[derive(Subcommand)]
pub enum HostlessCommand {
    /// Find Samsung Frame TVs on the local network
    Discover,

    /// Generate shell completions
    Completions {
        /// Shell to generate completions for
        shell: Option<Shell>,
    },
}

#[derive(Subcommand)]
pub enum ServerCommand {
    /// Start a background server for a TV
    Start,

    /// Stop the background server for a TV
    Stop,

    /// Restart the server for a TV
    Restart,

    /// Show server status (does not start a server)
    Status,

    /// Tail the server log file (like tail -F)
    TailLogs,
}

// ---------------------------------------------------------------------------
// Host CLI — for commands that require a TV host as the first argument
// ---------------------------------------------------------------------------

#[derive(Parser)]
#[command(name = "framesmith", version, about = "Control Samsung Frame TVs")]
pub struct HostCli {
    /// TV IP address or hostname
    pub host: String,

    #[command(subcommand)]
    pub command: HostCommand,

    /// Path to auth token file
    #[arg(short = 't', long = "auth-token-file", global = true, default_value_os_t = default_token_path())]
    pub auth_token_file: PathBuf,

    /// Connection timeout in seconds
    #[arg(long, global = true, default_value_t = 5)]
    pub timeout: u64,

    /// Emit all output as JSON
    #[arg(long, global = true)]
    pub json: bool,

    /// Enable verbose/debug output
    #[arg(short, long, global = true)]
    pub verbose: bool,

    /// Connect directly to the TV, bypassing the background server
    #[arg(long, global = true)]
    pub direct: bool,
}

fn default_token_path() -> PathBuf {
    dirs::home_dir()
        .unwrap_or_else(|| PathBuf::from("."))
        .join(".framesmith")
        .join("token")
}

#[derive(Subcommand)]
pub enum HostCommand {
    /// Manage TV authentication
    Auth {
        #[command(subcommand)]
        sub: Option<AuthCommand>,
    },

    /// Show device information
    Info,

    /// Art images, art mode, and slideshow
    Art {
        #[command(subcommand)]
        sub: ArtCommand,
    },

    /// Display settings
    Display {
        #[command(subcommand)]
        sub: DisplayCommand,
    },

    /// Motion sensor settings
    Motion {
        #[command(subcommand)]
        sub: MotionCommand,
    },

    /// Send remote control button press
    Remote {
        /// Button to press
        button: RemoteButton,
    },

    /// Manage background server process for this TV
    Server {
        #[command(subcommand)]
        sub: ServerCommand,
    },
}

// ---------------------------------------------------------------------------
// Auth
// ---------------------------------------------------------------------------

#[derive(Clone, Subcommand)]
pub enum AuthCommand {
    /// Check if the stored token is still valid
    Verify,
    /// Delete the locally stored auth token
    Reset,
}

// ---------------------------------------------------------------------------
// Art
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum ArtCommand {
    /// List uploaded art images
    List,

    /// Show content info for an art image (defaults to currently displayed)
    ShowInfo {
        /// Content ID to look up (omit for currently displayed image)
        content_id: Option<String>,
    },

    /// Select an art image for display
    Select {
        /// Content ID of the image to select
        content_id: String,
    },

    /// Upload an image to the TV
    Upload {
        /// Path to image file (JPEG or PNG)
        file: PathBuf,

        /// Select the image for display after uploading
        #[arg(long, conflicts_with = "replace_selected")]
        select: bool,

        /// Upload, select, then delete the previously selected image
        #[arg(long, conflicts_with = "select")]
        replace_selected: bool,

        /// Center image on a canvas of this color (black, white, or hex like #ff3300)
        #[arg(long)]
        canvas: Option<String>,
    },

    /// Delete uploaded art image(s)
    Delete {
        /// Content ID(s) to delete
        #[arg(required = true)]
        content_ids: Vec<String>,
    },

    /// Download thumbnail for an art image
    Thumbnail {
        /// Content ID of the image
        content_id: String,

        /// Output file path
        #[arg(short)]
        o: PathBuf,
    },

    /// Set/unset favorite on an art image
    Favorite {
        /// Content ID of the image
        content_id: String,

        /// Turn favorite on or off
        state: OnOff,
    },

    /// Matte settings
    Matte {
        #[command(subcommand)]
        sub: MatteCommand,
    },

    /// Photo filter settings
    Filter {
        #[command(subcommand)]
        sub: FilterCommand,
    },

    /// Art mode control
    Mode {
        #[command(subcommand)]
        sub: ModeCommand,
    },

    /// Slideshow control
    Slideshow {
        #[command(subcommand)]
        sub: SlideshowCommand,
    },
}

// ---------------------------------------------------------------------------
// Matte
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum MatteCommand {
    /// List available mattes
    List,

    /// Set matte on an image
    Set {
        /// Content ID of the image
        content_id: String,

        /// Matte ID to apply
        matte_id: String,

        /// Portrait matte ID (optional)
        #[arg(long)]
        portrait: Option<String>,
    },
}

// ---------------------------------------------------------------------------
// Filter
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum FilterCommand {
    /// List available photo filters
    List,

    /// Set filter on an image
    Set {
        /// Content ID of the image
        content_id: String,

        /// Filter ID to apply
        filter_id: String,
    },
}

// ---------------------------------------------------------------------------
// Mode
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum ModeCommand {
    /// Enable art mode
    On,
    /// Disable art mode
    Off,
    /// Check if art mode is enabled
    Status,
}

// ---------------------------------------------------------------------------
// Slideshow
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum SlideshowCommand {
    /// Enable slideshow
    On {
        /// Duration per image in seconds
        #[arg(long)]
        duration: Option<u64>,

        /// Shuffle images
        #[arg(long)]
        shuffle: bool,

        /// Image category
        #[arg(long)]
        category: Option<SlideshowCategoryValue>,
    },

    /// Disable slideshow
    Off,

    /// Show slideshow status and config
    Status,

    /// Update slideshow settings
    Configure {
        /// Duration per image in seconds
        #[arg(long)]
        duration: Option<u64>,

        /// Shuffle images
        #[arg(long)]
        shuffle: Option<OnOff>,

        /// Image category
        #[arg(long)]
        category: Option<SlideshowCategoryValue>,
    },
}

#[derive(Clone, ValueEnum)]
pub enum SlideshowCategoryValue {
    MyPictures,
    Favorites,
}

// ---------------------------------------------------------------------------
// Display
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum DisplayCommand {
    /// Get or set brightness (0-10)
    Brightness {
        /// Brightness level (0-10). Omit to get current value.
        value: Option<u8>,
    },

    /// Get or set color temperature (-5 to 5)
    ColorTemp {
        /// Color temperature (-5 to 5). Omit to get current value.
        value: Option<i8>,
    },

    /// Get display rotation
    Rotation,

    /// Enable or disable auto-brightness
    AutoBrightness {
        /// on or off
        state: OnOff,
    },
}

// ---------------------------------------------------------------------------
// Motion
// ---------------------------------------------------------------------------

#[derive(Subcommand)]
pub enum MotionCommand {
    /// Set motion timer
    Timer {
        /// Timer value in minutes
        value: MotionTimerValue,
    },

    /// Set motion sensitivity
    Sensitivity {
        /// Sensitivity level
        value: MotionSensitivityValue,
    },
}

#[derive(Clone, ValueEnum)]
pub enum MotionTimerValue {
    Off,
    #[value(name = "5")]
    Min5,
    #[value(name = "15")]
    Min15,
    #[value(name = "30")]
    Min30,
    #[value(name = "60")]
    Min60,
    #[value(name = "120")]
    Min120,
    #[value(name = "240")]
    Min240,
}

#[derive(Clone, ValueEnum)]
pub enum MotionSensitivityValue {
    Low,
    Medium,
    High,
}

// ---------------------------------------------------------------------------
// Shared value enums
// ---------------------------------------------------------------------------

#[derive(Clone, ValueEnum)]
pub enum OnOff {
    On,
    Off,
}

// ---------------------------------------------------------------------------
// Remote button
// ---------------------------------------------------------------------------

#[derive(Clone, ValueEnum)]
pub enum RemoteButton {
    Power,
    PowerOff,
    Sleep,
    Home,
    Menu,
    Source,
    Enter,
    Back,
    Return,
    Up,
    Down,
    Left,
    Right,
    VolUp,
    VolDown,
    Mute,
    ChUp,
    ChDown,
    ChList,
    Play,
    Pause,
    Stop,
    Rewind,
    FastForward,
    Info,
    Guide,
    Tools,
    Caption,
    #[value(name = "0")]
    Num0,
    #[value(name = "1")]
    Num1,
    #[value(name = "2")]
    Num2,
    #[value(name = "3")]
    Num3,
    #[value(name = "4")]
    Num4,
    #[value(name = "5")]
    Num5,
    #[value(name = "6")]
    Num6,
    #[value(name = "7")]
    Num7,
    #[value(name = "8")]
    Num8,
    #[value(name = "9")]
    Num9,
    Red,
    Green,
    Yellow,
    Blue,
    Ambient,
    PictureSize,
    Hdmi1,
    Hdmi2,
    Hdmi3,
    Hdmi4,
}

impl RemoteButton {
    #[allow(dead_code)]
    pub fn to_library_type(&self) -> framesmith::RemoteControlButton {
        use framesmith::RemoteControlButton::*;
        match self {
            Self::Power => Power,
            Self::PowerOff => PowerOff,
            Self::Sleep => Sleep,
            Self::Home => Home,
            Self::Menu => Menu,
            Self::Source => Source,
            Self::Enter => Enter,
            Self::Back => Back,
            Self::Return => Return,
            Self::Up => Up,
            Self::Down => Down,
            Self::Left => Left,
            Self::Right => Right,
            Self::VolUp => VolumeUp,
            Self::VolDown => VolumeDown,
            Self::Mute => Mute,
            Self::ChUp => ChannelUp,
            Self::ChDown => ChannelDown,
            Self::ChList => ChannelList,
            Self::Play => Play,
            Self::Pause => Pause,
            Self::Stop => Stop,
            Self::Rewind => Rewind,
            Self::FastForward => FastForward,
            Self::Info => Info,
            Self::Guide => Guide,
            Self::Tools => Tools,
            Self::Caption => Caption,
            Self::Num0 => Number0,
            Self::Num1 => Number1,
            Self::Num2 => Number2,
            Self::Num3 => Number3,
            Self::Num4 => Number4,
            Self::Num5 => Number5,
            Self::Num6 => Number6,
            Self::Num7 => Number7,
            Self::Num8 => Number8,
            Self::Num9 => Number9,
            Self::Red => Red,
            Self::Green => Green,
            Self::Yellow => Yellow,
            Self::Blue => Blue,
            Self::Ambient => Ambient,
            Self::PictureSize => PictureSize,
            Self::Hdmi1 => Hdmi1,
            Self::Hdmi2 => Hdmi2,
            Self::Hdmi3 => Hdmi3,
            Self::Hdmi4 => Hdmi4,
        }
    }

    /// Convert to the string used in the IPC protocol.
    pub fn to_ipc_string(&self) -> &'static str {
        match self {
            Self::Power => "power",
            Self::PowerOff => "power-off",
            Self::Sleep => "sleep",
            Self::Home => "home",
            Self::Menu => "menu",
            Self::Source => "source",
            Self::Enter => "enter",
            Self::Back => "back",
            Self::Return => "return",
            Self::Up => "up",
            Self::Down => "down",
            Self::Left => "left",
            Self::Right => "right",
            Self::VolUp => "vol-up",
            Self::VolDown => "vol-down",
            Self::Mute => "mute",
            Self::ChUp => "ch-up",
            Self::ChDown => "ch-down",
            Self::ChList => "ch-list",
            Self::Play => "play",
            Self::Pause => "pause",
            Self::Stop => "stop",
            Self::Rewind => "rewind",
            Self::FastForward => "fast-forward",
            Self::Info => "info",
            Self::Guide => "guide",
            Self::Tools => "tools",
            Self::Caption => "caption",
            Self::Num0 => "0",
            Self::Num1 => "1",
            Self::Num2 => "2",
            Self::Num3 => "3",
            Self::Num4 => "4",
            Self::Num5 => "5",
            Self::Num6 => "6",
            Self::Num7 => "7",
            Self::Num8 => "8",
            Self::Num9 => "9",
            Self::Red => "red",
            Self::Green => "green",
            Self::Yellow => "yellow",
            Self::Blue => "blue",
            Self::Ambient => "ambient",
            Self::PictureSize => "picture-size",
            Self::Hdmi1 => "hdmi1",
            Self::Hdmi2 => "hdmi2",
            Self::Hdmi3 => "hdmi3",
            Self::Hdmi4 => "hdmi4",
        }
    }
}

// ---------------------------------------------------------------------------
// Completion CLI — flat command list for shell completion generation
// ---------------------------------------------------------------------------

#[derive(Parser)]
#[command(name = "framesmith")]
pub struct CompletionCli {
    #[command(subcommand)]
    pub command: CompletionCommand,
}

#[derive(Subcommand)]
pub enum CompletionCommand {
    Discover,
    Completions {
        shell: Option<Shell>,
    },
    Server {
        #[command(subcommand)]
        sub: ServerCommand,
    },
    Auth {
        #[command(subcommand)]
        sub: Option<AuthCommand>,
    },
    Info,
    Art {
        #[command(subcommand)]
        sub: ArtCommand,
    },
    Display {
        #[command(subcommand)]
        sub: DisplayCommand,
    },
    Motion {
        #[command(subcommand)]
        sub: MotionCommand,
    },
    Remote {
        button: RemoteButton,
    },
}