// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//! This module provides common constants and helpers to assist in the unit-testing of other
//! modules within the crate.

use account_common::{LocalAccountId, LocalPersonaId};
use fidl::endpoints::{create_endpoints, ClientEnd};
use fidl_fuchsia_auth::AppConfig;
use fidl_fuchsia_auth_account::Status;
use fidl_fuchsia_auth_account_internal::{
    AccountHandlerContextMarker, AccountHandlerContextRequest, AccountHandlerContextRequestStream,
};
use fuchsia_async as fasync;
use futures::prelude::*;
use lazy_static::lazy_static;
use log::error;
use std::path::PathBuf;
use std::sync::Arc;
use tempfile::TempDir;

lazy_static! {
    pub static ref TEST_ACCOUNT_ID: LocalAccountId = LocalAccountId::new(111111);
    pub static ref TEST_PERSONA_ID: LocalPersonaId = LocalPersonaId::new(222222);
}

pub static TEST_APPLICATION_URL: &str = "test_app_url";

// TODO(jsankey): If fidl calls ever accept non-mutable structs, move this to a lazy_static.
// Currently FIDL requires mutable access to a type that doesn't support clone, so we just create a
// fresh instance each time.
pub fn create_dummy_app_config() -> AppConfig {
    AppConfig {
        auth_provider_type: "dummy_auth_provider".to_string(),
        client_id: None,
        client_secret: None,
        redirect_uri: None,
    }
}

pub struct TempLocation {
    /// A fresh temp directory that will be deleted when this object is dropped.
    _dir: TempDir,
    /// A path to an existing temp dir.
    pub path: PathBuf,
}

impl TempLocation {
    /// Return a writable, temporary location and optionally create it as a directory.
    pub fn new() -> TempLocation {
        let dir = TempDir::new().unwrap();
        let path = dir.path().to_path_buf();
        TempLocation { _dir: dir, path }
    }

    /// Returns a path to a static test path inside the temporary location which does not exist by
    /// default.
    pub fn test_path(&self) -> PathBuf {
        self.path.join("test_path")
    }
}

/// A fake meant for tests which rely on an AccountHandlerContext, but the context itself
/// isn't under test. As opposed to the real type, this doesn't depend on any other
/// components. Panics when getting unexpected messages or args, as defined by the implementation.
pub struct FakeAccountHandlerContext {}

impl FakeAccountHandlerContext {
    /// Creates new fake account handler context
    pub fn new() -> Self {
        Self {}
    }

    /// Asynchronously handles the supplied stream of `AccountHandlerContextRequest` messages.
    pub async fn handle_requests_from_stream(
        &self,
        mut stream: AccountHandlerContextRequestStream,
    ) -> Result<(), fidl::Error> {
        while let Some(req) = await!(stream.try_next())? {
            await!(self.handle_request(req))?;
        }
        Ok(())
    }

    /// Asynchronously handles a single `AccountHandlerContextRequest`.
    async fn handle_request(&self, req: AccountHandlerContextRequest) -> Result<(), fidl::Error> {
        match req {
            AccountHandlerContextRequest::GetAuthProvider { responder, .. } => {
                responder.send(Status::InternalError)
            }
        }
    }
}

/// Creates a new `AccountHandlerContext` channel, spawns a task to handle requests received on
/// this channel using the supplied `FakeAccountHandlerContext`, and returns the `ClientEnd`.
pub fn spawn_context_channel(
    context: Arc<FakeAccountHandlerContext>,
) -> ClientEnd<AccountHandlerContextMarker> {
    let (client_end, server_end) = create_endpoints().unwrap();
    let request_stream = server_end.into_stream().unwrap();
    let context_clone = Arc::clone(&context);
    fasync::spawn(async move {
        await!(context_clone.handle_requests_from_stream(request_stream))
            .unwrap_or_else(|err| error!("Error handling FakeAccountHandlerContext: {:?}", err))
    });
    client_end
}

#[cfg(test)]
mod tests {
    use super::*;

    #[fuchsia_async::run_until_stalled(test)]
    async fn test_context_fake() {
        let fake_context = Arc::new(FakeAccountHandlerContext::new());
        let client_end = spawn_context_channel(fake_context.clone());
        let proxy = client_end.into_proxy().unwrap();
        let (_, ap_server_end) = create_endpoints().expect("failed creating channel pair");
        assert_eq!(
            await!(proxy.get_auth_provider("dummy_auth_provider", ap_server_end)).unwrap(),
            Status::InternalError
        );
    }
}