use std::collections::HashSet;

use super::{Attributes, Method, Service};

use crate::{

    format_method_name, format_method_path, format_service_name, generate_deprecated, generate_doc_comments,

    naive_snake_case,

};

use proc_macro2::TokenStream;

use quote::{format_ident, quote};

pub(crate) fn generate_internal<T: Service>(

    service: &T, emit_package: bool, proto_path: &str, compile_well_known_types: bool, attributes: &Attributes,

    disable_comments: &HashSet<String>,

) -> TokenStream {

    let service_ident = quote::format_ident!("{}Client", service.name());

    let client_mod = quote::format_ident!("{}_client", naive_snake_case(service.name()));

    let methods = generate_methods(

        service,

        emit_package,

        proto_path,

        compile_well_known_types,

        disable_comments,

    );

    let rpcerr = generate_errors();

    let package = if emit_package { service.package() } else { "" };

    let service_name = format_service_name(service, emit_package);

    let service_doc = if disable_comments.contains(&service_name) {

        TokenStream::new()

    } else {

        generate_doc_comments(service.comment())

    };

    let mod_attributes = attributes.for_mod(package);

    let struct_attributes = attributes.for_struct(&service_name);

    quote! {

        /// Generated client implementations.

        #(#mod_attributes)*

        pub mod #client_mod {

            #![allow(

                unused_variables,

                dead_code,

                missing_docs,

                clippy::wildcard_imports,

                // will trigger if compression is disabled

                clippy::let_unit_value,

            )]

            use prost::Message;

            use http_body_util::{BodyExt, Full};

            use lyquor_net_rpc::http as http;

            pub use crate::pool::RequestSender;

            use thiserror::Error;

            #rpcerr

            #service_doc

            #(#struct_attributes)*

            #[derive(Clone)]

            pub struct #service_ident {

                sender: RequestSender,

            }

            impl #service_ident

            {

                pub fn new(s: RequestSender) -> Self {

                    Self { sender: s }

                }

                #methods

            }

        }

    }

}

fn generate_errors() -> TokenStream {

    quote! {

        #[derive(Debug, Error)]

        pub enum RPCError {

            #[error("bad request")]

            BadRequest,

            #[error("bad response")]

            BadResponse,

            #[error("check service")]

            CheckService,

            #[error("Transport error")]

            TransportErr,

            #[error("unknown error")]

            Unknown,

        }

    }

}

fn generate_methods<T: Service>(

    service: &T, emit_package: bool, proto_path: &str, compile_well_known_types: bool,

    disable_comments: &HashSet<String>,

) -> TokenStream {

    let mut stream = TokenStream::new();

    for method in service.methods() {

        if !disable_comments.contains(&format_method_name(service, method, emit_package)) {

            stream.extend(generate_doc_comments(method.comment()));

        }

        if method.deprecated() {

            stream.extend(generate_deprecated());

        }

        let method = generate_unary(service, method, emit_package, proto_path, compile_well_known_types);

        stream.extend(method);

    }

    stream

}

fn generate_unary<T: Service>(

    service: &T, method: &T::Method, emit_package: bool, proto_path: &str, compile_well_known_types: bool,

) -> TokenStream {

    let ident = format_ident!("{}", method.name());

    let (request, response) = method.request_response_name(proto_path, compile_well_known_types);

    let path = format_method_path(service, method, emit_package);

    quote! {

        pub async fn #ident(

            &mut self,

            request: #request,

        ) -> std::result::Result<#response, RPCError> {

           let path = http::uri::PathAndQuery::from_static(#path);

           let req_builder = http::Request::builder()

                .uri(path)

                .method("POST")

                .header("content-type", "application/grpc")

                .header("grpc-accept-encoding", "identity")

                .header("grpc-encoding", "identity")

                .header("lyquor-pkt-type", "RPC");

            let req = req_builder.body(Full::from(

                request.encode_to_vec()

            ));

            let req = match req {

                Ok(r) => r,

                Err(e) => {

                    return Err(RPCError::BadRequest)

                }

            };

            let resp = self.sender.send_request(req).await;

            match resp {

                Ok(resp) => {

                    let bytes = resp.collect().await;

                    match bytes {

                        Ok(b) => {

                            match #response::decode(b.to_bytes()) {

                                Ok(r) => {

                                    Ok(r)

                                },

                                Err(_) => {

                                    Err(RPCError::CheckService)

                                }

                            }

                        },

                        Err(e) => {

                            Err(RPCError::BadResponse)

                        }

                    }

                },

                Err(e) => Err(RPCError::TransportErr)

            }

           //self.inner.unary(req, path, codec).await

        }

    }

}