use std::convert::TryFrom;

use anyhow::anyhow;
use async_trait::async_trait;
use chrono::Utc;
use cynic::{MutationBuilder, QueryBuilder};
#[cfg(test)]
use mockall::automock;
use warp_core::channel::{Channel, ChannelState};
use warp_graphql::mutations::share_block::{
    BlockInput, ShareBlock, ShareBlockResult, ShareBlockVariables,
};
use warp_graphql::mutations::unshare_block::{
    UnshareBlock, UnshareBlockInput, UnshareBlockResult, UnshareBlockVariables,
};
use warp_graphql::queries::get_blocks_for_user::{
    Block as GqlBlock, GetBlocksForUser, GetBlocksForUserVariables,
};

use super::ServerApi;
use crate::ai::generate_block_title::api::{GenerateBlockTitleRequest, GenerateBlockTitleResponse};
use crate::server::block::{Block, DisplaySetting};
use crate::server::graphql::{get_request_context, get_user_facing_error_message};

#[cfg_attr(test, automock)]
#[cfg_attr(not(target_family = "wasm"), async_trait)]
#[cfg_attr(target_family = "wasm", async_trait(?Send))]
pub trait BlockClient: 'static + Send + Sync {
    /// Unshares a block identified at `block_id`.
    async fn unshare_block(&self, block_id: String) -> Result<(), anyhow::Error>;

    /// Uploads a given block to the server via the /share_block endpoint.
    async fn save_block(
        &self,
        block: &Block,
        title: Option<String>,
        show_prompt: bool,
        display_setting: DisplaySetting,
    ) -> Result<String, anyhow::Error>;

    async fn blocks_owned_by_user(&self) -> Result<Vec<Block>, anyhow::Error>;

    async fn generate_shared_block_title(
        &self,
        request: GenerateBlockTitleRequest,
    ) -> Result<GenerateBlockTitleResponse, anyhow::Error>;
}

#[cfg_attr(not(target_family = "wasm"), async_trait)]
#[cfg_attr(target_family = "wasm", async_trait(?Send))]
impl BlockClient for ServerApi {
    async fn unshare_block(&self, block_uid: String) -> Result<(), anyhow::Error> {
        let variables = UnshareBlockVariables {
            input: UnshareBlockInput { block_uid },
            request_context: get_request_context(),
        };

        let operation = UnshareBlock::build(variables);
        let response = self.send_graphql_request(operation, None).await?;
        match response.unshare_block {
            UnshareBlockResult::UnshareBlockOutput(output) => {
                if output.success {
                    Ok(())
                } else {
                    Err(anyhow!("Failed to unshare block"))
                }
            }
            UnshareBlockResult::UserFacingError(error) => {
                Err(anyhow!(get_user_facing_error_message(error)))
            }
            UnshareBlockResult::Unknown => Err(anyhow!("Failed to unshare block")),
        }
    }

    async fn save_block(
        &self,
        block: &Block,
        title: Option<String>,
        show_prompt: bool,
        display_setting: DisplaySetting,
    ) -> Result<String, anyhow::Error> {
        let variables = ShareBlockVariables {
            block: BlockInput {
                command: block.command.as_deref(),
                embed_display_setting: display_setting.into(),
                output: block.output.as_deref(),
                show_prompt,
                stylized_command: block.stylized_command.as_deref(),
                stylized_output: block.stylized_output.as_deref(),
                stylized_prompt: block.stylized_prompt.as_deref(),
                stylized_prompt_and_command: block.stylized_prompt_and_command.as_deref(),
                time_started_term: Some(block.time_started_term.with_timezone(&Utc).into()),
                title: title.as_deref(),
            },
            request_context: get_request_context(),
        };

        let operation = ShareBlock::build(variables);
        let response = self.send_graphql_request(operation, None).await?;
        match response.share_block {
            ShareBlockResult::ShareBlockOutput(output) => {
                let mut created_url =
                    format!("{}{}", ChannelState::server_root_url(), output.url_ending);

                // If this is a preview build, ensure the link routes to a preview build.
                if matches!(ChannelState::channel(), Channel::Preview) {
                    created_url.push_str("?preview=true");
                }

                Ok(created_url)
            }
            ShareBlockResult::UserFacingError(error) => {
                Err(anyhow!(get_user_facing_error_message(error)))
            }
            ShareBlockResult::Unknown => Err(anyhow!("Failed to share block")),
        }
    }

    async fn blocks_owned_by_user(&self) -> Result<Vec<Block>, anyhow::Error> {
        let variables = GetBlocksForUserVariables {
            request_context: get_request_context(),
        };
        let operation = GetBlocksForUser::build(variables);
        let response = self.send_graphql_request(operation, None).await?;

        match response.user {
            warp_graphql::queries::get_blocks_for_user::UserResult::UserOutput(user_output) => {
                Ok(user_output
                    .user
                    .blocks
                    .into_iter()
                    .filter_map(|block| block.try_into().ok())
                    .collect())
            }
            warp_graphql::queries::get_blocks_for_user::UserResult::Unknown => {
                Err(anyhow!("Unable to fetch blocks"))
            }
        }
    }

    async fn generate_shared_block_title(
        &self,
        request: GenerateBlockTitleRequest,
    ) -> Result<GenerateBlockTitleResponse, anyhow::Error> {
        let auth_token = self.get_or_refresh_access_token().await?;
        let request_builder = self.base_client.http_client().post(format!(
            "{}/ai/generate_block_title",
            ChannelState::server_root_url()
        ));
        let response = if let Some(token) = auth_token.as_bearer_token() {
            request_builder.bearer_auth(token)
        } else {
            request_builder
        }
        .json(&request)
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;
        Ok(response)
    }
}

impl TryFrom<GqlBlock> for Block {
    type Error = anyhow::Error;

    fn try_from(value: GqlBlock) -> Result<Self, Self::Error> {
        match (value.uid, value.time_started_term) {
            (uid, Some(time_started_term)) => {
                Ok(Block {
                    id: Some(uid.into_inner()),
                    command: value.command,
                    output: None,
                    stylized_command: None,
                    stylized_output: None,
                    pwd: None,
                    time_started_term: time_started_term.utc().into(),
                    // This is a dummy value - we are no longer using time_completed_term,
                    // and GqlBlock does not have a time_completed_term field.
                    time_completed_term: time_started_term.utc().into(),
                    stylized_prompt: None,
                    stylized_prompt_and_command: None,
                })
            }
            _ => Err(anyhow!("missing id or time_started_term")),
        }
    }
}