use std::env;
use std::path::PathBuf;
use std::process::ExitCode;
use std::time::Duration;

use clap::{Args, Parser, Subcommand, ValueEnum};
use futures_util::StreamExt;
use mxgateway_client::generated::galaxy_repository::v1::DeployEvent;
use mxgateway_client::generated::mxaccess_gateway::v1::{
    CloseSessionRequest, MxCommand, MxCommandKind, MxCommandRequest, OpenSessionRequest,
    PingCommand, StreamEventsRequest,
};
use mxgateway_client::{
    ApiKey, ClientOptions, Error, GalaxyClient, GatewayClient, MxValue, CLIENT_VERSION,
    GATEWAY_PROTOCOL_VERSION, WORKER_PROTOCOL_VERSION,
};
use serde_json::json;
use serde_json::Value;

const MAX_AGGREGATE_EVENTS: usize = 10_000;

#[derive(Debug, Parser)]
#[command(name = "mxgw")]
#[command(about = "MXAccess Gateway Rust test CLI")]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    Version {
        #[arg(long)]
        json: bool,
        #[arg(long)]
        jsonl: bool,
    },
    Ping {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long, default_value = "ping")]
        message: String,
        #[arg(long)]
        json: bool,
    },
    OpenSession {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long, default_value = "mxgw-rust-cli")]
        client_name: String,
        #[arg(long)]
        json: bool,
    },
    CloseSession {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        json: bool,
    },
    Register {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long, default_value = "mxgw-rust-cli")]
        client_name: String,
        #[arg(long)]
        json: bool,
    },
    AddItem {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long)]
        item: String,
        #[arg(long)]
        json: bool,
    },
    Advise {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long)]
        item_handle: i32,
        #[arg(long)]
        json: bool,
    },
    SubscribeBulk {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long, value_delimiter = ',')]
        items: Vec<String>,
        #[arg(long)]
        json: bool,
    },
    UnsubscribeBulk {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long, value_delimiter = ',')]
        item_handles: Vec<i32>,
        #[arg(long)]
        json: bool,
    },
    StreamEvents {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long, default_value_t = 0)]
        after_worker_sequence: u64,
        #[arg(long, default_value_t = 1)]
        max_events: usize,
        #[arg(long)]
        json: bool,
        #[arg(long)]
        jsonl: bool,
    },
    Write {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long)]
        item_handle: i32,
        #[arg(long, value_enum)]
        value_type: CliValueType,
        #[arg(long)]
        value: String,
        #[arg(long, default_value_t = 0)]
        user_id: i32,
        #[arg(long)]
        json: bool,
    },
    Write2 {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        session_id: String,
        #[arg(long)]
        server_handle: i32,
        #[arg(long)]
        item_handle: i32,
        #[arg(long, value_enum)]
        value_type: CliValueType,
        #[arg(long)]
        value: String,
        #[arg(long)]
        timestamp: String,
        #[arg(long, default_value_t = 0)]
        user_id: i32,
        #[arg(long)]
        json: bool,
    },
    Smoke {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        item: String,
        #[arg(long, default_value = "mxgw-rust-smoke")]
        client_name: String,
        #[arg(long)]
        json: bool,
    },
    #[command(subcommand)]
    Galaxy(GalaxyCommand),
}

#[derive(Debug, Subcommand)]
enum GalaxyCommand {
    TestConnection {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        json: bool,
    },
    LastDeployTime {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        json: bool,
    },
    DiscoverHierarchy {
        #[command(flatten)]
        connection: ConnectionArgs,
        #[arg(long)]
        json: bool,
    },
    /// Subscribe to the WatchDeployEvents server stream.
    ///
    /// Prints one line per received event (or one JSON object with `--json`).
    /// Runs until the stream ends, the server fails the call, or the
    /// process is interrupted (Ctrl+C).
    #[command(alias = "watch-deploy-events")]
    Watch {
        #[command(flatten)]
        connection: ConnectionArgs,
        /// Optional RFC3339 timestamp (e.g. `2026-04-28T15:30:00Z`). When
        /// supplied, the server suppresses the bootstrap event if its
        /// cached deploy time matches this value.
        #[arg(long)]
        last_seen_deploy_time: Option<String>,
        /// Optional cap on the number of events to print before exiting.
        /// 0 (the default) means run until cancelled or the stream ends.
        #[arg(long, default_value_t = 0)]
        max_events: usize,
        #[arg(long)]
        json: bool,
    },
}

#[derive(Debug, Args, Clone)]
struct ConnectionArgs {
    #[arg(long, default_value = "http://127.0.0.1:5000")]
    endpoint: String,
    #[arg(long)]
    api_key: Option<String>,
    #[arg(long, default_value = "MXGATEWAY_API_KEY")]
    api_key_env: String,
    #[arg(long)]
    plaintext: bool,
    #[arg(long)]
    tls: bool,
    #[arg(long)]
    ca_file: Option<PathBuf>,
    #[arg(long)]
    server_name_override: Option<String>,
    #[arg(long, default_value_t = 10)]
    connect_timeout_seconds: u64,
    #[arg(long, default_value_t = 30)]
    call_timeout_seconds: u64,
}

impl ConnectionArgs {
    fn options(&self) -> ClientOptions {
        let mut options = ClientOptions::new(self.endpoint.clone())
            .with_plaintext(!self.tls || self.plaintext)
            .with_connect_timeout(Duration::from_secs(self.connect_timeout_seconds))
            .with_call_timeout(Duration::from_secs(self.call_timeout_seconds));

        if let Some(api_key) = self
            .api_key
            .clone()
            .or_else(|| env::var(&self.api_key_env).ok())
            .filter(|value| !value.is_empty())
        {
            options = options.with_api_key(ApiKey::new(api_key));
        }
        if let Some(ca_file) = &self.ca_file {
            options = options.with_ca_file(ca_file);
        }
        if let Some(server_name_override) = &self.server_name_override {
            options = options.with_server_name_override(server_name_override);
        }

        options
    }
}

#[derive(Clone, Copy, Debug, ValueEnum)]
enum CliValueType {
    Bool,
    Int32,
    Int64,
    Float,
    Double,
    String,
}

#[tokio::main]
async fn main() -> ExitCode {
    let cli = Cli::parse();
    match run(cli).await {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) => {
            eprintln!("{error}");
            ExitCode::FAILURE
        }
    }
}

async fn run(cli: Cli) -> Result<(), Error> {
    match cli.command {
        Command::Version { json, .. } => print_version(json),
        Command::Ping {
            connection,
            message,
            json,
        } => {
            let client = connect(connection).await?;
            let reply = client
                .invoke(MxCommandRequest {
                    client_correlation_id: "rust-cli-ping".to_owned(),
                    command: Some(MxCommand {
                        kind: MxCommandKind::Ping as i32,
                        payload: Some(mxgateway_client::generated::mxaccess_gateway::v1::mx_command::Payload::Ping(
                            PingCommand { message },
                        )),
                    }),
                    ..MxCommandRequest::default()
                })
                .await?;
            print_command_reply("ping", &reply, json);
        }
        Command::OpenSession {
            connection,
            client_name,
            json,
        } => {
            let client = connect(connection).await?;
            let reply = client
                .open_session_raw(OpenSessionRequest {
                    client_session_name: client_name,
                    ..OpenSessionRequest::default()
                })
                .await?;
            if json {
                println!(
                    "{}",
                    json!({
                        "sessionId": reply.session_id,
                        "backendName": reply.backend_name,
                        "gatewayProtocolVersion": reply.gateway_protocol_version,
                        "workerProtocolVersion": reply.worker_protocol_version,
                    })
                );
            } else {
                println!("{}", reply.session_id);
            }
        }
        Command::CloseSession {
            connection,
            session_id,
            json,
        } => {
            let client = connect(connection).await?;
            let reply = client
                .close_session_raw(CloseSessionRequest {
                    session_id,
                    client_correlation_id: "rust-cli-close-session".to_owned(),
                })
                .await?;
            if json {
                println!("{}", json!({ "sessionId": reply.session_id }));
            } else {
                println!("closed {}", reply.session_id);
            }
        }
        Command::Register {
            connection,
            session_id,
            client_name,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            let server_handle = session.register(&client_name).await?;
            print_handle("serverHandle", server_handle, json);
        }
        Command::AddItem {
            connection,
            session_id,
            server_handle,
            item,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            let item_handle = session.add_item(server_handle, &item).await?;
            print_handle("itemHandle", item_handle, json);
        }
        Command::Advise {
            connection,
            session_id,
            server_handle,
            item_handle,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            session.advise(server_handle, item_handle).await?;
            print_ok("advise", json);
        }
        Command::SubscribeBulk {
            connection,
            session_id,
            server_handle,
            items,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            let results = session.subscribe_bulk(server_handle, items).await?;
            print_bulk_results("subscribe-bulk", &results, json);
        }
        Command::UnsubscribeBulk {
            connection,
            session_id,
            server_handle,
            item_handles,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            let results = session
                .unsubscribe_bulk(server_handle, item_handles)
                .await?;
            print_bulk_results("unsubscribe-bulk", &results, json);
        }
        Command::StreamEvents {
            connection,
            session_id,
            after_worker_sequence,
            max_events,
            json,
            jsonl,
        } => {
            if max_events > MAX_AGGREGATE_EVENTS {
                return Err(Error::InvalidArgument {
                    name: "max-events".to_owned(),
                    detail: format!("must be less than or equal to {MAX_AGGREGATE_EVENTS}"),
                });
            }

            let client = connect(connection).await?;
            let mut stream = client
                .stream_events(StreamEventsRequest {
                    session_id,
                    after_worker_sequence,
                })
                .await?;
            let mut events = Vec::new();
            let mut event_count = 0usize;
            while event_count < max_events {
                let Some(event) = stream.next().await else {
                    break;
                };
                let event = event?;
                event_count += 1;
                if jsonl {
                    println!(
                        "{}",
                        json!({
                            "workerSequence": event.worker_sequence,
                            "family": event.family,
                        })
                    );
                } else if json {
                    events.push(event);
                } else {
                    println!("{} {}", event.worker_sequence, event.family);
                }
            }
            if json {
                println!("{}", json!({ "eventCount": event_count }));
            }
        }
        Command::Write {
            connection,
            session_id,
            server_handle,
            item_handle,
            value_type,
            value,
            user_id,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            session
                .write(
                    server_handle,
                    item_handle,
                    parse_value(value_type, &value)?,
                    user_id,
                )
                .await?;
            print_ok("write", json);
        }
        Command::Write2 {
            connection,
            session_id,
            server_handle,
            item_handle,
            value_type,
            value,
            timestamp,
            user_id,
            json,
        } => {
            let session = session_for(connection, session_id).await?;
            session
                .write2(
                    server_handle,
                    item_handle,
                    parse_value(value_type, &value)?,
                    MxValue::string(timestamp),
                    user_id,
                )
                .await?;
            print_ok("write2", json);
        }
        Command::Galaxy(galaxy_command) => run_galaxy(galaxy_command).await?,
        Command::Smoke {
            connection,
            item,
            client_name,
            json,
        } => {
            let client = connect(connection).await?;
            let session = client
                .open_session(OpenSessionRequest {
                    client_session_name: client_name.clone(),
                    ..OpenSessionRequest::default()
                })
                .await?;
            let result = async {
                let server_handle = session.register(&client_name).await?;
                let item_handle = session.add_item(server_handle, &item).await?;
                session.advise(server_handle, item_handle).await?;
                Ok::<_, Error>((server_handle, item_handle))
            }
            .await;
            let close_result = session.close().await;
            let (server_handle, item_handle) = result?;
            close_result?;
            if json {
                println!(
                    "{}",
                    json!({
                        "sessionId": session.id(),
                        "serverHandle": server_handle,
                        "itemHandle": item_handle,
                        "closed": true,
                    })
                );
            } else {
                println!(
                    "session {} registered server {server_handle}, item {item_handle}, closed",
                    session.id()
                );
            }
        }
    }

    Ok(())
}

async fn connect(connection: ConnectionArgs) -> Result<GatewayClient, Error> {
    GatewayClient::connect(connection.options()).await
}

async fn connect_galaxy(connection: ConnectionArgs) -> Result<GalaxyClient, Error> {
    GalaxyClient::connect(connection.options()).await
}

async fn run_galaxy(command: GalaxyCommand) -> Result<(), Error> {
    match command {
        GalaxyCommand::TestConnection { connection, json } => {
            let mut client = connect_galaxy(connection).await?;
            let ok = client.test_connection().await?;
            if json {
                println!("{}", json!({ "ok": ok }));
            } else if ok {
                println!("ok");
            } else {
                println!("not ok");
            }
        }
        GalaxyCommand::LastDeployTime { connection, json } => {
            let mut client = connect_galaxy(connection).await?;
            let timestamp = client.get_last_deploy_time().await?;
            match (json, timestamp) {
                (true, Some(ts)) => {
                    println!(
                        "{}",
                        json!({
                            "present": true,
                            "seconds": ts.seconds,
                            "nanos": ts.nanos,
                        })
                    );
                }
                (true, None) => {
                    println!("{}", json!({ "present": false }));
                }
                (false, Some(ts)) => println!("{}.{:09}", ts.seconds, ts.nanos),
                (false, None) => println!("(absent)"),
            }
        }
        GalaxyCommand::Watch {
            connection,
            last_seen_deploy_time,
            max_events,
            json,
        } => {
            let mut client = connect_galaxy(connection).await?;
            let last_seen = last_seen_deploy_time
                .as_deref()
                .map(parse_rfc3339_timestamp)
                .transpose()?;
            let mut stream = client.watch_deploy_events(last_seen).await?;

            let mut count = 0usize;
            loop {
                tokio::select! {
                    biased;
                    signal = tokio::signal::ctrl_c() => {
                        signal.map_err(|err| Error::InvalidArgument {
                            name: "ctrl_c".to_owned(),
                            detail: err.to_string(),
                        })?;
                        // Drop the stream below by breaking; tonic tears the
                        // gRPC call down cooperatively.
                        break;
                    }
                    next = stream.next() => {
                        let Some(event) = next else { break; };
                        let event = event?;
                        count += 1;
                        print_deploy_event(&event, json);
                        if max_events != 0 && count >= max_events {
                            break;
                        }
                    }
                }
            }
        }
        GalaxyCommand::DiscoverHierarchy { connection, json } => {
            let mut client = connect_galaxy(connection).await?;
            let objects = client.discover_hierarchy().await?;
            if json {
                let payload: Vec<_> = objects
                    .iter()
                    .map(|object| {
                        json!({
                            "gobjectId": object.gobject_id,
                            "tagName": object.tag_name,
                            "containedName": object.contained_name,
                            "browseName": object.browse_name,
                            "parentGobjectId": object.parent_gobject_id,
                            "isArea": object.is_area,
                            "categoryId": object.category_id,
                            "hostedByGobjectId": object.hosted_by_gobject_id,
                            "templateChain": object.template_chain,
                            "attributes": object.attributes.iter().map(|attribute| json!({
                                "attributeName": attribute.attribute_name,
                                "fullTagReference": attribute.full_tag_reference,
                                "mxDataType": attribute.mx_data_type,
                                "dataTypeName": attribute.data_type_name,
                                "isArray": attribute.is_array,
                                "arrayDimension": attribute.array_dimension,
                                "arrayDimensionPresent": attribute.array_dimension_present,
                                "mxAttributeCategory": attribute.mx_attribute_category,
                                "securityClassification": attribute.security_classification,
                                "isHistorized": attribute.is_historized,
                                "isAlarm": attribute.is_alarm,
                            })).collect::<Vec<_>>(),
                        })
                    })
                    .collect();
                println!("{}", json!({ "objects": payload }));
            } else {
                println!("{}", objects.len());
                for object in &objects {
                    println!(
                        "{} {} {} ({} attribute(s))",
                        object.gobject_id,
                        object.tag_name,
                        object.browse_name,
                        object.attributes.len()
                    );
                }
            }
        }
    }
    Ok(())
}

async fn session_for(
    connection: ConnectionArgs,
    session_id: String,
) -> Result<mxgateway_client::Session, Error> {
    let client = connect(connection).await?;
    Ok(client.session(session_id))
}

fn print_version(use_json: bool) {
    if use_json {
        println!("{}", version_json());
        return;
    }

    println!("mxgw {CLIENT_VERSION}");
    println!("gateway protocol {GATEWAY_PROTOCOL_VERSION}");
    println!("worker protocol {WORKER_PROTOCOL_VERSION}");
}

fn version_json() -> Value {
    json!({
        "clientVersion": CLIENT_VERSION,
        "gatewayProtocolVersion": GATEWAY_PROTOCOL_VERSION,
        "workerProtocolVersion": WORKER_PROTOCOL_VERSION,
    })
}

fn print_command_reply(
    operation: &str,
    reply: &mxgateway_client::generated::mxaccess_gateway::v1::MxCommandReply,
    use_json: bool,
) {
    if use_json {
        println!(
            "{}",
            json!({
                "operation": operation,
                "sessionId": reply.session_id,
                "correlationId": reply.correlation_id,
                "kind": reply.kind,
            })
        );
    } else {
        println!("{operation} completed");
    }
}

fn print_handle(name: &str, handle: i32, use_json: bool) {
    if use_json {
        println!("{}", json!({ name: handle }));
    } else {
        println!("{handle}");
    }
}

fn print_ok(operation: &str, use_json: bool) {
    if use_json {
        println!("{}", json!({ "operation": operation, "ok": true }));
    } else {
        println!("{operation} completed");
    }
}

fn print_bulk_results(
    operation: &str,
    results: &[mxgateway_client::generated::mxaccess_gateway::v1::SubscribeResult],
    use_json: bool,
) {
    if use_json {
        let results_json: Vec<_> = results
            .iter()
            .map(|result| {
                json!({
                    "serverHandle": result.server_handle,
                    "tagAddress": result.tag_address,
                    "itemHandle": result.item_handle,
                    "wasSuccessful": result.was_successful,
                    "errorMessage": result.error_message,
                })
            })
            .collect();
        println!(
            "{}",
            json!({ "operation": operation, "results": results_json })
        );
    } else {
        println!("{}", results.len());
    }
}

fn parse_value(value_type: CliValueType, value: &str) -> Result<MxValue, Error> {
    let parsed = match value_type {
        CliValueType::Bool => MxValue::bool(parse_cli_value(value)?),
        CliValueType::Int32 => MxValue::int32(parse_cli_value(value)?),
        CliValueType::Int64 => MxValue::int64(parse_cli_value(value)?),
        CliValueType::Float => MxValue::float(parse_cli_value(value)?),
        CliValueType::Double => MxValue::double(parse_cli_value(value)?),
        CliValueType::String => MxValue::string(value),
    };
    Ok(parsed)
}

fn print_deploy_event(event: &DeployEvent, use_json: bool) {
    if use_json {
        println!(
            "{}",
            json!({
                "sequence": event.sequence,
                "observedAt": event.observed_at.as_ref().map(|ts| json!({
                    "seconds": ts.seconds,
                    "nanos": ts.nanos,
                })),
                "timeOfLastDeploy": event.time_of_last_deploy.as_ref().map(|ts| json!({
                    "seconds": ts.seconds,
                    "nanos": ts.nanos,
                })),
                "timeOfLastDeployPresent": event.time_of_last_deploy_present,
                "objectCount": event.object_count,
                "attributeCount": event.attribute_count,
            })
        );
    } else {
        let observed = event
            .observed_at
            .as_ref()
            .map(|ts| format!("{}.{:09}", ts.seconds, ts.nanos))
            .unwrap_or_else(|| "(absent)".to_owned());
        let last_deploy = if event.time_of_last_deploy_present {
            event
                .time_of_last_deploy
                .as_ref()
                .map(|ts| format!("{}.{:09}", ts.seconds, ts.nanos))
                .unwrap_or_else(|| "(absent)".to_owned())
        } else {
            "(absent)".to_owned()
        };
        println!(
            "seq={} observed={} lastDeploy={} objects={} attributes={}",
            event.sequence, observed, last_deploy, event.object_count, event.attribute_count,
        );
    }
}

/// Parse a small but practically-complete subset of RFC3339:
/// `YYYY-MM-DDTHH:MM:SS[.fffffffff][Z|+HH:MM|-HH:MM]`. Returns the
/// corresponding `prost_types::Timestamp` (Unix seconds + nanoseconds).
fn parse_rfc3339_timestamp(input: &str) -> Result<prost_types::Timestamp, Error> {
    fn invalid(detail: impl Into<String>) -> Error {
        Error::InvalidArgument {
            name: "last-seen-deploy-time".to_owned(),
            detail: detail.into(),
        }
    }

    let bytes = input.as_bytes();
    if bytes.len() < 20 || (bytes[10] != b'T' && bytes[10] != b't') {
        return Err(invalid(format!(
            "expected RFC3339 timestamp like 2026-04-28T15:30:00Z, got {input:?}"
        )));
    }

    let read_u32 = |start: usize, len: usize| -> Result<u32, Error> {
        std::str::from_utf8(&bytes[start..start + len])
            .ok()
            .and_then(|slice| slice.parse::<u32>().ok())
            .ok_or_else(|| invalid(format!("non-numeric digits at byte {start}")))
    };

    let year = read_u32(0, 4)? as i32;
    if bytes[4] != b'-' {
        return Err(invalid("expected '-' after year"));
    }
    let month = read_u32(5, 2)?;
    if bytes[7] != b'-' {
        return Err(invalid("expected '-' after month"));
    }
    let day = read_u32(8, 2)?;
    let hour = read_u32(11, 2)?;
    if bytes[13] != b':' {
        return Err(invalid("expected ':' after hour"));
    }
    let minute = read_u32(14, 2)?;
    if bytes[16] != b':' {
        return Err(invalid("expected ':' after minute"));
    }
    let second = read_u32(17, 2)?;

    let mut cursor = 19usize;
    let mut nanos: u32 = 0;
    if cursor < bytes.len() && bytes[cursor] == b'.' {
        cursor += 1;
        let frac_start = cursor;
        while cursor < bytes.len() && bytes[cursor].is_ascii_digit() {
            cursor += 1;
        }
        let frac_len = cursor - frac_start;
        if frac_len == 0 {
            return Err(invalid("expected fractional digits after '.'"));
        }
        let take = frac_len.min(9);
        let frac = std::str::from_utf8(&bytes[frac_start..frac_start + take])
            .ok()
            .and_then(|slice| slice.parse::<u32>().ok())
            .ok_or_else(|| invalid("invalid fractional digits"))?;
        nanos = frac * 10u32.pow(9u32.saturating_sub(take as u32));
    }

    let mut offset_seconds: i64 = 0;
    if cursor >= bytes.len() {
        return Err(invalid("missing timezone designator (Z or +HH:MM)"));
    }
    match bytes[cursor] {
        b'Z' | b'z' => cursor += 1,
        sign @ (b'+' | b'-') => {
            cursor += 1;
            if cursor + 5 > bytes.len() {
                return Err(invalid("offset must be ±HH:MM"));
            }
            let oh = std::str::from_utf8(&bytes[cursor..cursor + 2])
                .ok()
                .and_then(|slice| slice.parse::<i64>().ok())
                .ok_or_else(|| invalid("invalid offset hour"))?;
            if bytes[cursor + 2] != b':' {
                return Err(invalid("offset must contain ':' between HH and MM"));
            }
            let om = std::str::from_utf8(&bytes[cursor + 3..cursor + 5])
                .ok()
                .and_then(|slice| slice.parse::<i64>().ok())
                .ok_or_else(|| invalid("invalid offset minute"))?;
            cursor += 5;
            let signed = if sign == b'-' { -1 } else { 1 };
            offset_seconds = signed * (oh * 3600 + om * 60);
        }
        other => {
            return Err(invalid(format!(
                "unexpected timezone designator byte {other:?}"
            )));
        }
    }
    if cursor != bytes.len() {
        return Err(invalid("trailing characters after timezone"));
    }

    let unix = ymdhms_to_unix(year, month, day, hour, minute, second)?;
    let seconds = unix - offset_seconds;

    Ok(prost_types::Timestamp {
        seconds,
        nanos: nanos as i32,
    })
}

fn ymdhms_to_unix(
    year: i32,
    month: u32,
    day: u32,
    hour: u32,
    minute: u32,
    second: u32,
) -> Result<i64, Error> {
    if !(1..=12).contains(&month) || day < 1 || hour > 23 || minute > 59 || second > 60 {
        return Err(Error::InvalidArgument {
            name: "last-seen-deploy-time".to_owned(),
            detail: "calendar component out of range".to_owned(),
        });
    }
    fn is_leap(year: i32) -> bool {
        (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
    }
    const DAYS: [u32; 12] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    let mut max = DAYS[(month - 1) as usize];
    if month == 2 && is_leap(year) {
        max = 29;
    }
    if day > max {
        return Err(Error::InvalidArgument {
            name: "last-seen-deploy-time".to_owned(),
            detail: format!("day {day} out of range for month {month}/{year}"),
        });
    }

    // Days from 1970-01-01 to year-month-day.
    let mut total_days: i64 = 0;
    if year >= 1970 {
        for y in 1970..year {
            total_days += if is_leap(y) { 366 } else { 365 };
        }
    } else {
        for y in year..1970 {
            total_days -= if is_leap(y) { 366 } else { 365 };
        }
    }
    for m in 1..month {
        let mut dim = DAYS[(m - 1) as usize];
        if m == 2 && is_leap(year) {
            dim = 29;
        }
        total_days += dim as i64;
    }
    total_days += (day - 1) as i64;

    Ok(total_days * 86_400 + hour as i64 * 3600 + minute as i64 * 60 + second as i64)
}

fn parse_cli_value<T>(value: &str) -> Result<T, Error>
where
    T: std::str::FromStr,
    T::Err: std::fmt::Display,
{
    value.parse::<T>().map_err(|source| Error::InvalidArgument {
        name: "value".to_owned(),
        detail: source.to_string(),
    })
}

#[cfg(test)]
mod tests {
    use clap::Parser;

    use super::Cli;

    #[test]
    fn parses_version_json_command() {
        let parsed = Cli::try_parse_from(["mxgw", "version", "--json"]);
        assert!(parsed.is_ok());
    }

    #[test]
    fn parses_write_command() {
        let parsed = Cli::try_parse_from([
            "mxgw",
            "write",
            "--session-id",
            "session-1",
            "--server-handle",
            "12",
            "--item-handle",
            "34",
            "--value-type",
            "int32",
            "--value",
            "123",
        ]);
        assert!(parsed.is_ok());
    }

    #[test]
    fn version_json_output_has_protocol_versions() {
        let value = super::version_json();

        assert_eq!(value["gatewayProtocolVersion"], 2);
        assert_eq!(value["workerProtocolVersion"], 1);
    }

    #[test]
    fn parses_galaxy_watch_command_with_last_seen_and_max_events() {
        let parsed = Cli::try_parse_from([
            "mxgw",
            "galaxy",
            "watch",
            "--last-seen-deploy-time",
            "2026-04-28T15:30:00Z",
            "--max-events",
            "5",
            "--json",
        ]);
        assert!(parsed.is_ok(), "parse failed: {parsed:?}");
    }

    #[test]
    fn parses_galaxy_watch_deploy_events_alias() {
        let parsed = Cli::try_parse_from(["mxgw", "galaxy", "watch-deploy-events"]);
        assert!(parsed.is_ok(), "parse failed: {parsed:?}");
    }

    #[test]
    fn rfc3339_parser_round_trips_z_and_offset_inputs() {
        // 2026-04-28T15:30:00Z = 1_777_995_000 (sanity-checked once below)
        let utc = super::parse_rfc3339_timestamp("2026-04-28T15:30:00Z").unwrap();
        let plus = super::parse_rfc3339_timestamp("2026-04-28T16:30:00+01:00").unwrap();
        let frac = super::parse_rfc3339_timestamp("2026-04-28T15:30:00.250Z").unwrap();

        assert_eq!(utc.seconds, plus.seconds);
        assert_eq!(utc.nanos, 0);
        assert_eq!(frac.seconds, utc.seconds);
        assert_eq!(frac.nanos, 250_000_000);
    }
}