use super::one::Web3Rpc;
use crate::errors::{Web3ProxyError, Web3ProxyErrorContext, Web3ProxyResult};
use crate::frontend::authorization::{Authorization, AuthorizationType};
use crate::globals::{global_db_conn, DB_CONN};
use crate::jsonrpc::{
    self, JsonRpcErrorData, JsonRpcResultData, ResponsePayload, ValidatedRequest,
};
use anyhow::Context;
use chrono::Utc;
use derive_more::From;
use entities::revert_log;
use entities::sea_orm_active_enums::Method;
use ethers::providers::ProviderError;
use ethers::types::{Address, Bytes};
use futures::Future;
use http::StatusCode;
use migration::sea_orm::{self, ActiveEnum, ActiveModelTrait};
use nanorand::Rng;
use serde_json::json;
use std::pin::Pin;
use std::sync::atomic;
use std::sync::Arc;
use tokio::time::{Duration, Instant};
use tracing::{debug, error, info, trace, warn, Level};

#[derive(From)]
pub enum OpenRequestResult {
    Handle(OpenRequestHandle),
    /// Unable to start a request. Retry at the given time.
    RetryAt(Instant),
    /// The rpc are not synced, but they should be soon.
    /// You should wait for the given block number.
    /// TODO: should this return an OpenRequestHandle? that might recurse
    Lagged(Pin<Box<dyn Future<Output = Web3ProxyResult<Arc<Web3Rpc>>> + Send>>),
    /// Unable to start a request because no servers are synced or the necessary data has been pruned
    Failed,
}

/// Make RPC requests through this handle and drop it when you are done.
/// Opening this handle checks rate limits. Developers, try to keep opening a handle and using it as close together as possible
pub struct OpenRequestHandle {
    web3_request: Arc<ValidatedRequest>,
    error_handler: RequestErrorHandler,
    rpc: Arc<Web3Rpc>,
}

/// Depending on the context, RPC errors require different handling.
#[derive(Copy, Clone, Debug, Default)]
pub enum RequestErrorHandler {
    /// Log at the trace level. Use when errors are expected.
    #[default]
    TraceLevel,
    /// Log at the debug level. Use when errors are expected.
    DebugLevel,
    /// Log at the info level. Use when errors are expected.
    InfoLevel,
    /// Log at the error level. Use when errors are bad.
    ErrorLevel,
    /// Log at the warn level. Use when errors do not cause problems.
    WarnLevel,
    /// Potentially save the revert. Users can tune how often this happens
    Save,
}

// TODO: second param could be skipped since we don't need it here
#[derive(serde::Deserialize, serde::Serialize)]
struct EthCallParams((EthCallFirstParams, Option<serde_json::Value>));

#[derive(serde::Deserialize, serde::Serialize)]
struct EthCallFirstParams {
    to: Option<Address>,
    data: Option<Bytes>,
}

impl std::fmt::Debug for OpenRequestHandle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("OpenRequestHandle")
            .field("method", &self.web3_request.inner.method())
            .field("rpc", &self.rpc.name)
            .finish_non_exhaustive()
    }
}

impl From<Level> for RequestErrorHandler {
    fn from(level: Level) -> Self {
        match level {
            Level::DEBUG => RequestErrorHandler::DebugLevel,
            Level::ERROR => RequestErrorHandler::ErrorLevel,
            Level::INFO => RequestErrorHandler::InfoLevel,
            Level::TRACE => RequestErrorHandler::TraceLevel,
            Level::WARN => RequestErrorHandler::WarnLevel,
        }
    }
}

impl Authorization {
    /// Save a RPC call that return "execution reverted" to the database.
    async fn save_revert(
        self: Arc<Self>,
        method: Method,
        params: EthCallFirstParams,
    ) -> Web3ProxyResult<()> {
        let rpc_key_id = match self.checks.rpc_secret_key_id {
            Some(rpc_key_id) => rpc_key_id.into(),
            None => {
                // trace!(?self, "cannot save revert without rpc_key_id");
                return Ok(());
            }
        };

        let db_conn = global_db_conn()?;

        // TODO: should the database set the timestamp?
        // we intentionally use "now" and not the time the request started
        // why? because we aggregate stats and setting one in the past could cause confusion
        let timestamp = Utc::now();

        let to = params.to.unwrap_or_else(Address::zero).as_bytes().to_vec();

        let call_data = params.data.map(|x| x.to_string());

        let rl = revert_log::ActiveModel {
            rpc_key_id: sea_orm::Set(rpc_key_id),
            method: sea_orm::Set(method),
            to: sea_orm::Set(to),
            call_data: sea_orm::Set(call_data),
            timestamp: sea_orm::Set(timestamp),
            ..Default::default()
        };

        let rl = rl
            .save(&db_conn)
            .await
            .web3_context("Failed saving new revert log")?;

        // TODO: what log level and format?
        trace!(revert_log=?rl);

        // TODO: return something useful
        Ok(())
    }
}

impl Drop for OpenRequestHandle {
    fn drop(&mut self) {
        self.rpc
            .active_requests
            .fetch_sub(1, atomic::Ordering::Relaxed);
    }
}

impl OpenRequestHandle {
    pub async fn new(
        web3_request: Arc<ValidatedRequest>,
        rpc: Arc<Web3Rpc>,
        error_handler: Option<RequestErrorHandler>,
    ) -> Self {
        // TODO: take request_id as an argument?
        // TODO: attach a unique id to this? customer requests have one, but not internal queries
        // TODO: what ordering?!
        rpc.active_requests
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);

        let error_handler = error_handler.unwrap_or_default();

        Self {
            web3_request,
            error_handler,
            rpc,
        }
    }

    pub fn connection_name(&self) -> String {
        self.rpc.name.clone()
    }

    #[inline]
    pub fn clone_connection(&self) -> Arc<Web3Rpc> {
        self.rpc.clone()
    }

    pub fn rate_limit_for(&self, duration: Duration) {
        if self.rpc.backup {
            debug!(?duration, "rate limited on {}!", self.rpc);
        } else {
            warn!(?duration, "rate limited on {}!", self.rpc);
        }

        // TODO: use send_if_modified to be sure we only send if our value is greater
        self.rpc
            .hard_limit_until
            .as_ref()
            .unwrap()
            .send_replace(Instant::now() + duration);
    }

    /// Just get the response from the provider without any extra handling.
    /// This lets us use the try operator which makes it much easier to read
    async fn _request<R: JsonRpcResultData + serde::Serialize>(
        &self,
    ) -> Web3ProxyResult<jsonrpc::SingleResponse<R>> {
        // TODO: replace ethers-rs providers with our own that supports streaming the responses
        // TODO: replace ethers-rs providers with our own that handles "id" being null
        if let (Some(url), Some(ref client)) = (self.rpc.http_url.clone(), &self.rpc.http_client) {
            // prefer the http provider
            let request = self
                .web3_request
                .inner
                .jsonrpc_request()
                .context("there should always be a request here")?;

            let response = client.post(url).json(request).send().await?;

            if response.status() == StatusCode::TOO_MANY_REQUESTS {
                // TODO: how much should we actually rate limit?
                self.rate_limit_for(Duration::from_secs(1));
            }

            let response = response.error_for_status()?;

            jsonrpc::SingleResponse::read_if_short(response, 1024, &self.web3_request).await
        } else if let Some(p) = self.rpc.ws_provider.load().as_ref() {
            // use the websocket provider if no http provider is available
            let method = self.web3_request.inner.method();
            let params = self.web3_request.inner.params();

            // some ethers::ProviderError need to be converted to JsonRpcErrorData. the rest to Web3ProxyError
            let response = match p.request::<_, R>(method, params).await {
                Ok(x) => jsonrpc::ParsedResponse::from_result(x, self.web3_request.id()),
                Err(provider_error) => match JsonRpcErrorData::try_from(&provider_error) {
                    Ok(x) => jsonrpc::ParsedResponse::from_error(x, self.web3_request.id()),
                    Err(ProviderError::HTTPError(error)) => {
                        if let Some(status_code) = error.status() {
                            if status_code == StatusCode::TOO_MANY_REQUESTS {
                                // TODO: how much should we actually rate limit?
                                self.rate_limit_for(Duration::from_secs(1));
                            }
                        }
                        return Err(provider_error.into());
                    }
                    Err(err) => {
                        warn!(?err, "error from {}", self.rpc);

                        return Err(provider_error.into());
                    }
                },
            };

            Ok(response.into())
        } else {
            // this must be a test
            Err(anyhow::anyhow!("no provider configured!").into())
        }
    }

    pub fn error_handler(&self) -> RequestErrorHandler {
        if let RequestErrorHandler::Save = self.error_handler {
            let method = self.web3_request.inner.method();

            // TODO: should all these be Trace or Debug or a mix?
            // TODO: this list should come from config. other methods might be desired
            if !["eth_call", "eth_estimateGas"].contains(&method) {
                // trace!(%method, "skipping save on revert");
                RequestErrorHandler::TraceLevel
            } else if DB_CONN.read().is_ok() {
                let log_revert_chance = self.web3_request.authorization.checks.log_revert_chance;

                if log_revert_chance == 0 {
                    // trace!(%method, "no chance. skipping save on revert");
                    RequestErrorHandler::TraceLevel
                } else if log_revert_chance == u16::MAX {
                    // trace!(%method, "gaurenteed chance. SAVING on revert");
                    self.error_handler
                } else if nanorand::tls_rng().generate_range(0u16..u16::MAX) < log_revert_chance {
                    // trace!(%method, "missed chance. skipping save on revert");
                    RequestErrorHandler::TraceLevel
                } else {
                    // trace!("Saving on revert");
                    // TODO: is always logging at debug level fine?
                    self.error_handler
                }
            } else {
                // trace!(%method, "no database. skipping save on revert");
                RequestErrorHandler::TraceLevel
            }
        } else {
            self.error_handler
        }
    }

    /// Send a web3 request
    /// By having the request method here, we ensure that the rate limiter was called and connection counts were properly incremented
    /// depending on how things are locked, you might need to pass the provider in
    /// we take self to ensure this function only runs once
    /// This does some inspection of the response to check for non-standard errors and rate limiting to try to give a Web3ProxyError instead of an Ok
    pub async fn request<R: JsonRpcResultData + serde::Serialize>(
        self,
    ) -> Web3ProxyResult<jsonrpc::SingleResponse<R>> {
        // TODO: use tracing spans
        // TODO: including params in this log is way too verbose
        // trace!(rpc=%self.rpc, %method, "request");
        trace!("requesting from {}", self.rpc);

        let authorization = &self.web3_request.authorization;

        match &authorization.authorization_type {
            AuthorizationType::Frontend => {
                self.rpc
                    .external_requests
                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
            }
            AuthorizationType::Internal => {
                self.rpc
                    .internal_requests
                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
            }
        }

        // we used to fetch_add the active_request count here, but sometimes a request is made without going through this function (like with subscriptions)

        // we generally don't want to use the try operator. we might need to log errors
        let start = Instant::now();

        let mut response = self._request().await;

        // measure successes and errors
        // originally i thought we wouldn't want errors, but I think it's a more accurate number including all requests
        let latency = start.elapsed();

        // we used to fetch_sub the active_request count here, but sometimes the handle is dropped without request being called!

        trace!(
            "response from {} for {}: {:?}",
            self.rpc,
            self.web3_request,
            response,
        );

        // TODO: move this to a helper function?
        // true if we got a jsonrpc result. a jsonrpc error or other error is false.
        // TODO: counters for errors vs jsonrpc vs success?
        let response_is_success = match &response {
            Ok(jsonrpc::SingleResponse::Parsed(x)) => {
                matches!(&x.payload, ResponsePayload::Success { .. })
            }
            Ok(jsonrpc::SingleResponse::Stream(..)) => true,
            Err(_) => false,
        };

        if response_is_success {
            // only track latency for successful requests
            tokio::spawn(async move {
                self.rpc.peak_latency.as_ref().unwrap().report(latency);
                self.rpc.median_latency.as_ref().unwrap().record(latency);

                // TODO: app-wide median and peak latency?
            });
        } else {
            // only save reverts for some types of calls
            // TODO: do something special for eth_sendRawTransaction too
            // we do **NOT** use self.error_handler here because it might have been modified
            let error_handler = self.error_handler();

            enum ResponseType {
                Error,
                Revert,
                RateLimited,
            }

            let response_type: ResponseType = match &response {
                Ok(jsonrpc::SingleResponse::Parsed(x)) => match &x.payload {
                    ResponsePayload::Success { .. } => unreachable!(),
                    ResponsePayload::Error { error } => {
                        trace!(?error, "jsonrpc error data");

                        if error.message.starts_with("execution reverted") {
                            ResponseType::Revert
                        } else if error.code == StatusCode::TOO_MANY_REQUESTS.as_u16() as i64 {
                            ResponseType::RateLimited
                        } else {
                            // TODO! THIS HAS TOO MANY FALSE POSITIVES! Theres another spot in the code that checks for things.
                            // if error.message.contains("limit") || error.message.contains("request") {
                            //     self.rate_limit_for(Duration::from_secs(1));
                            // }

                            match error.code {
                                -32000 => {
                                    if error.message.contains("MDBX_PANIC:") {
                                        response = Err(Web3ProxyError::MdbxPanic(
                                            self.connection_name(),
                                            error.message.clone(),
                                        ));
                                    } else {
                                        // TODO: regex?
                                        let archive_prefixes = [
                                            "header not found",
                                            "header for hash not found",
                                            "missing trie node",
                                        ];
                                        for prefix in archive_prefixes {
                                            if error.message.starts_with(prefix) {
                                                // TODO: what error?
                                                response = Err(Web3ProxyError::ArchiveRequired {
                                                    min: self.web3_request.min_block_needed(),
                                                    max: self.web3_request.max_block_needed(),
                                                });
                                                break;
                                            }
                                        }
                                    }

                                    ResponseType::Error
                                }
                                -32001 => {
                                    if error.message == "Exceeded the quota usage" {
                                        ResponseType::RateLimited
                                    } else {
                                        ResponseType::Error
                                    }
                                }
                                -32005 => {
                                    if error.message == "rate limit exceeded" {
                                        ResponseType::RateLimited
                                    } else {
                                        ResponseType::Error
                                    }
                                }
                                -32601 => {
                                    let error_msg = error.message.as_ref();

                                    // sometimes a provider does not support all rpc methods
                                    // we check other connections rather than returning the error
                                    // but sometimes the method is something that is actually unsupported,
                                    // so we save the response here to return it later

                                    // some providers look like this
                                    if (error_msg.starts_with("the method")
                                        && error_msg.ends_with("is not available"))
                                        || error_msg == "Method not found"
                                    {
                                        let method = self.web3_request.inner.method().to_string();

                                        response =
                                            Err(Web3ProxyError::MethodNotFound(method.into()))
                                    }

                                    ResponseType::Error
                                }
                                _ => ResponseType::Error,
                            }
                        }
                    }
                },
                Ok(jsonrpc::SingleResponse::Stream(..)) => unreachable!(),
                Err(_) => ResponseType::Error,
            };

            if matches!(response_type, ResponseType::RateLimited) {
                // TODO: how long?
                self.rate_limit_for(Duration::from_secs(1));
            }

            match error_handler {
                RequestErrorHandler::DebugLevel => {
                    // TODO: think about this revert check more. sometimes we might want reverts logged so this needs a flag
                    if matches!(response_type, ResponseType::Revert) {
                        trace!(
                            rpc=%self.rpc,
                            %self.web3_request,
                            ?response,
                            "revert",
                        );
                    } else {
                        debug!(
                            rpc=%self.rpc,
                            %self.web3_request,
                            ?response,
                            "bad response",
                        );
                    }
                }
                RequestErrorHandler::InfoLevel => {
                    info!(
                        rpc=%self.rpc,
                        %self.web3_request,
                        ?response,
                        "bad response",
                    );
                }
                RequestErrorHandler::TraceLevel => {
                    trace!(
                        rpc=%self.rpc,
                        %self.web3_request,
                        ?response,
                        "bad response",
                    );
                }
                RequestErrorHandler::ErrorLevel => {
                    // TODO: only include params if not running in release mode
                    error!(
                        rpc=%self.rpc,
                        %self.web3_request,
                        ?response,
                        "bad response",
                    );
                }
                RequestErrorHandler::WarnLevel => {
                    // TODO: only include params if not running in release mode
                    warn!(
                        rpc=%self.rpc,
                        %self.web3_request,
                        ?response,
                        "bad response",
                    );
                }
                RequestErrorHandler::Save => {
                    trace!(
                        rpc=%self.rpc,
                        %self.web3_request,
                        ?response,
                        "bad response",
                    );

                    // TODO: do not unwrap! (doesn't matter much since we check method as a string above)
                    // TODO: open this up for even more methods
                    let method: Method =
                        Method::try_from_value(&self.web3_request.inner.method().to_string())
                            .unwrap();

                    // TODO: i don't think this prsing is correct
                    match serde_json::from_value::<EthCallParams>(json!(self
                        .web3_request
                        .inner
                        .params()))
                    {
                        Ok(params) => {
                            // spawn saving to the database so we don't slow down the request
                            // TODO: log if this errors
                            // TODO: aren't the method and params already saved? this should just need the response
                            let f = authorization.clone().save_revert(method, params.0 .0);

                            tokio::spawn(f);
                        }
                        Err(err) => {
                            warn!(
                                %self.web3_request,
                                ?response,
                                ?err,
                                "failed parsing eth_call params. unable to save revert",
                            );
                        }
                    }
                }
            }
        }

        response
    }
}