#[doc = r#" handle "xyz" requests "#]
# [tracing :: instrument (skip (rqctx , arg1) , parent = None , fields (http . request . method = "GET" , http . route = "/term" , http . response . status_code = 0 , trace . trace_id = tracing :: field :: Empty , trace . parent_id = tracing :: field :: Empty , api_call . id = tracing :: field :: Empty ,) ,)]
# [dropshot :: channel { protocol = WEBSOCKETS , path = "/term" , tags = ["term"] , deprecated = false , unpublished = false , }]
#[autometrics::autometrics]
async fn create_term(
    rqctx: dropshot::RequestContext<Arc<Context>>,
    arg0: Query<Thing>,
    arg1: dropshot::WebsocketConnection,
) -> dropshot::WebsocketChannelResult {
    let root_span = tracing::Span::current();
    root_span.record("api_call.id", rqctx.request_id.to_string());
    use dropshot::HttpCodedResponse;
    use opentelemetry::trace::TraceContextExt;
    use std::str::FromStr;
    use tracing_opentelemetry::OpenTelemetrySpanExt;
    if let Some(traceparent) = rqctx.request.headers().get("traceparent") {
        if let Ok(tps) = traceparent.to_str() {
            if tps.len() == 55 {
                let segs: Vec<&str> = tps.split('-').collect();
                if segs.len() == 4 {
                    if let Ok(version) = u8::from_str_radix(segs[0], 16) {
                        if let Ok(trace_id) = u128::from_str_radix(segs[1], 16) {
                            if let Ok(parent_id) = u64::from_str_radix(segs[2], 16) {
                                if let Ok(flags) = u8::from_str_radix(segs[3], 16) {
                                    let trace_flags = opentelemetry::trace::TraceFlags::new(flags)
                                        & opentelemetry::trace::TraceFlags::SAMPLED;
                                    let trace_state =
                                        match rqctx.request.headers().get("tracestate") {
                                            Some(trace_state) => {
                                                opentelemetry::trace::TraceState::from_str(
                                                    trace_state.to_str().unwrap_or_default(),
                                                )
                                                .unwrap_or_else(|_| {
                                                    opentelemetry::trace::TraceState::default()
                                                })
                                            }
                                            None => opentelemetry::trace::TraceState::default(),
                                        };
                                    let span_context = opentelemetry::trace::SpanContext::new(
                                        trace_id.into(),
                                        parent_id.into(),
                                        trace_flags,
                                        true,
                                        trace_state,
                                    );
                                    if span_context.is_valid() {
                                        let context = root_span
                                            .context()
                                            .with_remote_span_context(span_context);
                                        root_span.set_parent(context);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    match zoo_endpoint_create_term::create_term(rqctx, arg0, arg1).await {
        Ok(r) => {
            root_span.record("http.response.status_code", 200);
            Ok(r)
        }

        Err(e) => Err(common::server::handle_anyhow_err_as_http_err(e.into()).into()),
    }
}

mod zoo_endpoint_create_term {
    use super::*;
    #[doc = r#" handle "xyz" requests "#]
    async fn create_term(
        rqctx: dropshot::RequestContext<Arc<Context>>,
        query_params: Query<Thing>,
        upgraded: dropshot::WebsocketConnection,
    ) -> Result<()> {
        let token = rqctx.context().require_auth(&rqctx).await?;
        match crate::server::handlers::create_term(&rqctx, upgraded, &token).await {
            Ok(_) => Ok(()),
            Err(err) => Err(common::error::Error::InternalError {
                internal_message: format!("term stopped with error: {}", err),
            }
            .into()),
        }
    }
}