//! Define a response type for directory requests.

use std::str;

use http::Method;

use tor_linkspec::{LoggedChanTarget, OwnedChanTarget};

use tor_proto::circuit::UniqId;

use crate::{RequestError, RequestFailedError};

/// A successful (or at any rate, well-formed) response to a directory

/// request.

#[derive(Debug, Clone)]

#[must_use = "You need to check whether the response was successful."]

pub struct DirResponse {

    /// The HTTP method of the request.

    method: Method,

    /// An HTTP status code.

    status: u16,

    /// The message associated with the status code.

    status_message: Option<String>,

    /// The decompressed output that we got from the directory cache.

    output: Vec<u8>,

    /// The error, if any, that caused us to stop getting this response early.

    error: Option<RequestError>,

    /// Information about the directory cache we used.

    source: Option<SourceInfo>,

}

/// Information about the source of a directory response.

///

/// We use this to remember when a request has failed, so we can

/// abandon the circuit.

#[derive(Debug, Clone, derive_more::Display)]

#[display("{} via {}", cache_id, tunnel)]

pub struct SourceInfo {

    /// Unique identifier for the circuit we're using

    tunnel: UniqId,

    /// Identity of the directory cache that provided us this information.

    cache_id: LoggedChanTarget,

}

impl DirResponse {

    /// Construct a new DirResponse from its parts

    /// Construct a new successful DirResponse to a GET request from its body.

    /// Return the HTTP status code for this response.

    /// Return true if this is in incomplete response.

    /// Return the error from this response, if any.

    /// Return the output from this response.

    ///

    /// Returns some output, even if the response indicates truncation or an error.

    /// Return the output from this response, if it was successful and complete.

    /// Return this the output from this response, as a string,

    /// if it was successful and complete and valid UTF-8.

            // For RequestError::Utf8Encoding We need a `String::FromUtf8Error`

            // (which contains an owned copy of the bytes).

    /// Consume this DirResponse and return the output in it.

    ///

    /// Returns some output, even if the response indicates truncation or an error.

    /// Consume this DirResponse and return the output, if it was successful and complete.

    /// Consume this DirResponse and return the output, as a string,

    /// if it was successful and complete and valid UTF-8.

    /// Return the source information about this response.

    /// Check if this request was successful and complete.

            };

        // We do not allow a successful response with an empty body on GET.

}

impl SourceInfo {

    /// Try to construct a new SourceInfo representing the last hop of a given tunnel.

    ///

    /// Return an error if the tunnel is closed;

    /// return `Ok(None)` if the circuit's last hop is virtual.

        }

    /// Return the unique circuit identifier for the circuit on which

    /// we received this info.

    /// Return information about the peer from which we received this info.

}

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_time_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    #[test]

    fn errors() {

        let mut response = DirResponse::new(Method::GET, 200, None, None, vec![b'Y'], None);

        assert_eq!(response.output().unwrap(), b"Y");

        assert_eq!(response.clone().into_output().unwrap(), b"Y");

        let expect_error = |response: &DirResponse, error: RequestError| {

            let error = RequestFailedError {

                error,

                source: None,

            };

            let error = format!("{:?}", error);

            assert_eq!(error, format!("{:?}", response.output().unwrap_err()));

            assert_eq!(

                error,

                format!("{:?}", response.clone().into_output().unwrap_err())

            );

        };

        let with_error = |response: &DirResponse| {

            let mut response = response.clone();

            response.error = Some(RequestError::DirTimeout);

            expect_error(&response, RequestError::DirTimeout);

        };

        with_error(&response);

        response.output = vec![];

        expect_error(&response, RequestError::EmptyResponse);

        response.status = 404;

        response.status_message = Some("Not found".into());

        expect_error(&response, RequestError::HttpStatus(404, "Not found".into()));

        with_error(&response);

    }

}