use std::{
    borrow::Cow,
    collections::HashMap,
    fmt::{Display, Error, Formatter},
};

use ethers_core::{
    abi::Address,
    types::{BlockNumber, Bytes, H256, U256, U64},
};
use serde::{Deserialize, Serialize};

use crate::{Client, EtherscanError, Query, Response, Result};

/// The raw response from the balance-related API endpoints
#[derive(Debug, Serialize, Deserialize)]
pub struct AccountBalance {
    pub account: Address,
    pub balance: String,
}

mod jsonstring {
    use super::*;
    use serde::{
        de::{DeserializeOwned, Error as _},
        ser::Error as _,
        Deserializer, Serializer,
    };

    pub fn serialize<T, S>(
        value: &GenesisOption<T>,
        serializer: S,
    ) -> std::result::Result<S::Ok, S::Error>
    where
        T: Serialize,
        S: Serializer,
    {
        let json = match value {
            GenesisOption::None => Cow::from(""),
            GenesisOption::Genesis => Cow::from("GENESIS"),
            GenesisOption::Some(value) => {
                serde_json::to_string(value).map_err(S::Error::custom)?.into()
            }
        };
        serializer.serialize_str(&json)
    }

    pub fn deserialize<'de, T, D>(
        deserializer: D,
    ) -> std::result::Result<GenesisOption<T>, D::Error>
    where
        T: DeserializeOwned,
        D: Deserializer<'de>,
    {
        let json = Cow::<'de, str>::deserialize(deserializer)?;
        if !json.is_empty() && !json.starts_with("GENESIS") {
            let value =
                serde_json::from_str(&format!("\"{}\"", &json)).map_err(D::Error::custom)?;
            Ok(GenesisOption::Some(value))
        } else if json.starts_with("GENESIS") {
            Ok(GenesisOption::Genesis)
        } else {
            Ok(GenesisOption::None)
        }
    }
}

/// Possible values for some field responses
#[derive(Debug)]
pub enum GenesisOption<T> {
    None,
    Genesis,
    Some(T),
}

impl<T> From<GenesisOption<T>> for Option<T> {
    fn from(value: GenesisOption<T>) -> Self {
        match value {
            GenesisOption::Some(value) => Some(value),
            _ => None,
        }
    }
}

impl<T> GenesisOption<T> {
    pub fn is_genesis(&self) -> bool {
        matches!(self, GenesisOption::Genesis)
    }

    pub fn value(&self) -> Option<&T> {
        match self {
            GenesisOption::Some(value) => Some(value),
            _ => None,
        }
    }
}

/// The raw response from the transaction list API endpoint
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NormalTransaction {
    pub is_error: String,
    pub block_number: BlockNumber,
    pub time_stamp: String,
    #[serde(with = "jsonstring")]
    pub hash: GenesisOption<H256>,
    #[serde(with = "jsonstring")]
    pub nonce: GenesisOption<U256>,
    #[serde(with = "jsonstring")]
    pub block_hash: GenesisOption<U256>,
    pub transaction_index: Option<U64>,
    #[serde(with = "jsonstring")]
    pub from: GenesisOption<Address>,
    pub to: Option<Address>,
    pub value: U256,
    pub gas: U256,
    pub gas_price: Option<U256>,
    #[serde(rename = "txreceipt_status")]
    pub tx_receipt_status: String,
    #[serde(with = "jsonstring")]
    pub input: GenesisOption<Bytes>,
    #[serde(with = "jsonstring")]
    pub contract_address: GenesisOption<Address>,
    pub gas_used: U256,
    pub cumulative_gas_used: U256,
    pub confirmations: U64,
}

/// The raw response from the internal transaction list API endpoint
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InternalTransaction {
    pub block_number: BlockNumber,
    pub time_stamp: String,
    pub hash: H256,
    pub from: Address,
    #[serde(with = "jsonstring")]
    pub to: GenesisOption<Address>,
    pub value: U256,
    #[serde(with = "jsonstring")]
    pub contract_address: GenesisOption<Address>,
    #[serde(with = "jsonstring")]
    pub input: GenesisOption<Bytes>,
    #[serde(rename = "type")]
    pub result_type: String,
    pub gas: U256,
    pub gas_used: U256,
    pub trace_id: String,
    pub is_error: String,
    pub err_code: String,
}

/// The raw response from the ERC20 transfer list API endpoint
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ERC20TokenTransferEvent {
    pub block_number: BlockNumber,
    pub time_stamp: String,
    pub hash: H256,
    pub nonce: U256,
    pub block_hash: H256,
    pub from: Address,
    pub contract_address: Address,
    pub to: Option<Address>,
    pub value: U256,
    pub token_name: String,
    pub token_symbol: String,
    pub token_decimal: String,
    pub transaction_index: U64,
    pub gas: U256,
    pub gas_price: Option<U256>,
    pub gas_used: U256,
    pub cumulative_gas_used: U256,
    /// deprecated
    pub input: String,
    pub confirmations: U64,
}

/// The raw response from the ERC721 transfer list API endpoint
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ERC721TokenTransferEvent {
    pub block_number: BlockNumber,
    pub time_stamp: String,
    pub hash: H256,
    pub nonce: U256,
    pub block_hash: H256,
    pub from: Address,
    pub contract_address: Address,
    pub to: Option<Address>,
    #[serde(rename = "tokenID")]
    pub token_id: String,
    pub token_name: String,
    pub token_symbol: String,
    pub token_decimal: String,
    pub transaction_index: U64,
    pub gas: U256,
    pub gas_price: Option<U256>,
    pub gas_used: U256,
    pub cumulative_gas_used: U256,
    /// deprecated
    pub input: String,
    pub confirmations: U64,
}

/// The raw response from the mined blocks API endpoint
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MinedBlock {
    pub block_number: BlockNumber,
    pub time_stamp: String,
    pub block_reward: String,
}

/// The pre-defined block parameter for balance API endpoints
pub enum Tag {
    Earliest,
    Pending,
    Latest,
}

impl Display for Tag {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
        match self {
            Tag::Earliest => write!(f, "earliest"),
            Tag::Pending => write!(f, "pending"),
            Tag::Latest => write!(f, "latest"),
        }
    }
}

impl Default for Tag {
    fn default() -> Self {
        Tag::Latest
    }
}

/// The list sorting preference
pub enum Sort {
    Asc,
    Desc,
}

impl Display for Sort {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
        match self {
            Sort::Asc => write!(f, "asc"),
            Sort::Desc => write!(f, "desc"),
        }
    }
}

/// Common optional arguments for the transaction or event list API endpoints
pub struct TxListParams {
    start_block: u64,
    end_block: u64,
    page: u64,
    offset: u64,
    sort: Sort,
}

impl TxListParams {
    pub fn new(start_block: u64, end_block: u64, page: u64, offset: u64, sort: Sort) -> Self {
        Self { start_block, end_block, page, offset, sort }
    }
}

impl Default for TxListParams {
    fn default() -> Self {
        Self { start_block: 0, end_block: 99999999, page: 0, offset: 10000, sort: Sort::Asc }
    }
}

impl From<TxListParams> for HashMap<&'static str, String> {
    fn from(tx_params: TxListParams) -> Self {
        let mut params = HashMap::new();
        params.insert("startBlock", tx_params.start_block.to_string());
        params.insert("endBlock", tx_params.end_block.to_string());
        params.insert("page", tx_params.page.to_string());
        params.insert("offset", tx_params.offset.to_string());
        params.insert("sort", tx_params.sort.to_string());
        params
    }
}

/// Options for querying internal transactions
pub enum InternalTxQueryOption {
    ByAddress(Address),
    ByTransactionHash(H256),
    ByBlockRange,
}

/// Options for querying ERC20 or ERC721 token transfers
pub enum TokenQueryOption {
    ByAddress(Address),
    ByContract(Address),
    ByAddressAndContract(Address, Address),
}

impl TokenQueryOption {
    pub fn into_params(self, list_params: TxListParams) -> HashMap<&'static str, String> {
        let mut params: HashMap<&'static str, String> = list_params.into();
        match self {
            TokenQueryOption::ByAddress(address) => {
                params.insert("address", format!("{:?}", address));
                params
            }
            TokenQueryOption::ByContract(contract) => {
                params.insert("contractaddress", format!("{:?}", contract));
                params
            }
            TokenQueryOption::ByAddressAndContract(address, contract) => {
                params.insert("address", format!("{:?}", address));
                params.insert("contractaddress", format!("{:?}", contract));
                params
            }
        }
    }
}

/// The pre-defined block type for retrieving mined blocks
pub enum BlockType {
    CanonicalBlocks,
    Uncles,
}

impl Display for BlockType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), Error> {
        match self {
            BlockType::CanonicalBlocks => write!(f, "blocks"),
            BlockType::Uncles => write!(f, "uncles"),
        }
    }
}

impl Default for BlockType {
    fn default() -> Self {
        BlockType::CanonicalBlocks
    }
}

impl Client {
    /// Returns the Ether balance of a given address.
    ///
    /// ```no_run
    /// # use ethers_etherscan::Client;
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let balance = client
    ///         .get_ether_balance_single(&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
    ///         None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_ether_balance_single(
        &self,
        address: &Address,
        tag: Option<Tag>,
    ) -> Result<AccountBalance> {
        let tag_str = tag.unwrap_or_default().to_string();
        let addr_str = format!("{:?}", address);
        let query = self.create_query(
            "account",
            "balance",
            HashMap::from([("address", &addr_str), ("tag", &tag_str)]),
        );
        let response: Response<String> = self.get_json(&query).await?;

        match response.status.as_str() {
            "0" => Err(EtherscanError::BalanceFailed),
            "1" => Ok(AccountBalance { account: *address, balance: response.result }),
            err => Err(EtherscanError::BadStatusCode(err.to_string())),
        }
    }

    /// Returns the balance of the accounts from a list of addresses.
    ///
    /// ```no_run
    /// # use ethers_etherscan::Client;
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let balances = client
    ///         .get_ether_balance_multi(&vec![&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap()],
    ///         None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_ether_balance_multi(
        &self,
        addresses: &[&Address],
        tag: Option<Tag>,
    ) -> Result<Vec<AccountBalance>> {
        let tag_str = tag.unwrap_or_default().to_string();
        let addrs = addresses.iter().map(|x| format!("{:?}", x)).collect::<Vec<String>>().join(",");
        let query: Query<HashMap<&str, &str>> = self.create_query(
            "account",
            "balancemulti",
            HashMap::from([("address", addrs.as_ref()), ("tag", tag_str.as_ref())]),
        );
        let response: Response<Vec<AccountBalance>> = self.get_json(&query).await?;

        match response.status.as_str() {
            "0" => Err(EtherscanError::BalanceFailed),
            "1" => Ok(response.result),
            err => Err(EtherscanError::BadStatusCode(err.to_string())),
        }
    }

    /// Returns the list of transactions performed by an address, with optional pagination.
    ///
    /// ```no_run
    /// # use ethers_etherscan::Client;
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let txs = client
    ///         .get_transactions(&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
    ///         None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_transactions(
        &self,
        address: &Address,
        params: Option<TxListParams>,
    ) -> Result<Vec<NormalTransaction>> {
        let mut tx_params: HashMap<&str, String> = params.unwrap_or_default().into();
        tx_params.insert("address", format!("{:?}", address));
        let query = self.create_query("account", "txlist", tx_params);
        let response: Response<Vec<NormalTransaction>> = self.get_json(&query).await?;

        Ok(response.result)
    }

    /// Returns the list of internal transactions performed by an address or within a transaction,
    /// with optional pagination.
    ///
    /// ```no_run
    /// # use ethers_etherscan::{Client, account::InternalTxQueryOption};
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let txs = client
    ///         .get_internal_transactions(
    ///             InternalTxQueryOption::ByAddress(
    ///                 "0x2c1ba59d6f58433fb1eaee7d20b26ed83bda51a3".parse().unwrap()), None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_internal_transactions(
        &self,
        tx_query_option: InternalTxQueryOption,
        params: Option<TxListParams>,
    ) -> Result<Vec<InternalTransaction>> {
        let mut tx_params: HashMap<&str, String> = params.unwrap_or_default().into();
        match tx_query_option {
            InternalTxQueryOption::ByAddress(address) => {
                tx_params.insert("address", format!("{:?}", address));
            }
            InternalTxQueryOption::ByTransactionHash(tx_hash) => {
                tx_params.insert("txhash", format!("{:?}", tx_hash));
            }
            _ => {}
        }
        let query = self.create_query("account", "txlistinternal", tx_params);
        let response: Response<Vec<InternalTransaction>> = self.get_json(&query).await?;

        Ok(response.result)
    }

    /// Returns the list of ERC-20 tokens transferred by an address, with optional filtering by
    /// token contract.
    ///
    /// ```no_run
    /// # use ethers_etherscan::{Client, account::TokenQueryOption};
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let txs = client
    ///         .get_erc20_token_transfer_events(
    ///             TokenQueryOption::ByAddress(
    ///                 "0x4e83362442b8d1bec281594cea3050c8eb01311c".parse().unwrap()), None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_erc20_token_transfer_events(
        &self,
        event_query_option: TokenQueryOption,
        params: Option<TxListParams>,
    ) -> Result<Vec<ERC20TokenTransferEvent>> {
        let params = event_query_option.into_params(params.unwrap_or_default());
        let query = self.create_query("account", "tokentx", params);
        let response: Response<Vec<ERC20TokenTransferEvent>> = self.get_json(&query).await?;

        Ok(response.result)
    }

    /// Returns the list of ERC-721 ( NFT ) tokens transferred by an address, with optional
    /// filtering by token contract.
    ///
    /// ```no_run
    /// # use ethers_etherscan::{Client, account::TokenQueryOption};
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let txs = client
    ///         .get_erc721_token_transfer_events(
    ///             TokenQueryOption::ByAddressAndContract(
    ///                 "0x6975be450864c02b4613023c2152ee0743572325".parse().unwrap(),
    ///                 "0x06012c8cf97bead5deae237070f9587f8e7a266d".parse().unwrap(),
    ///          ), None).await.unwrap();
    /// # }
    /// ```
    pub async fn get_erc721_token_transfer_events(
        &self,
        event_query_option: TokenQueryOption,
        params: Option<TxListParams>,
    ) -> Result<Vec<ERC721TokenTransferEvent>> {
        let params = event_query_option.into_params(params.unwrap_or_default());
        let query = self.create_query("account", "tokennfttx", params);
        let response: Response<Vec<ERC721TokenTransferEvent>> = self.get_json(&query).await?;

        Ok(response.result)
    }

    /// Returns the list of blocks mined by an address.
    ///
    /// ```no_run
    /// # use ethers_etherscan::Client;
    /// # use ethers_core::types::Chain;
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    ///     let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    ///     let blocks = client
    ///         .get_mined_blocks(&"0x9dd134d14d1e65f84b706d6f205cd5b1cd03a46b".parse().unwrap(), None, None)
    ///         .await.unwrap();
    /// # }
    /// ```
    pub async fn get_mined_blocks(
        &self,
        address: &Address,
        block_type: Option<BlockType>,
        page_and_offset: Option<(u64, u64)>,
    ) -> Result<Vec<MinedBlock>> {
        let mut params = HashMap::new();
        params.insert("address", format!("{:?}", address));
        params.insert("blocktype", block_type.unwrap_or_default().to_string());
        if let Some((page, offset)) = page_and_offset {
            params.insert("page", page.to_string());
            params.insert("offset", offset.to_string());
        }
        let query = self.create_query("account", "getminedblocks", params);
        let response: Response<Vec<MinedBlock>> = self.get_json(&query).await?;

        Ok(response.result)
    }
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use serial_test::serial;

    use crate::{tests::run_at_least_duration, Chain};

    use super::*;

    #[tokio::test]
    #[serial]
    async fn get_ether_balance_single_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let balance = client
                .get_ether_balance_single(
                    &"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
                    None,
                )
                .await;
            assert!(balance.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_ether_balance_multi_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let balances = client
                .get_ether_balance_multi(
                    &[&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap()],
                    None,
                )
                .await;
            assert!(balances.is_ok());
            let balances = balances.unwrap();
            assert!(balances.len() == 1);
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_transactions_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let txs = client
                .get_transactions(
                    &"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
                    None,
                )
                .await;
            dbg!(&txs);
            assert!(txs.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_internal_transactions_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let txs = client
                .get_internal_transactions(
                    InternalTxQueryOption::ByAddress(
                        "0x2c1ba59d6f58433fb1eaee7d20b26ed83bda51a3".parse().unwrap(),
                    ),
                    None,
                )
                .await;
            assert!(txs.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_internal_transactions_by_tx_hash_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let txs = client
                .get_internal_transactions(
                    InternalTxQueryOption::ByTransactionHash(
                        "0x40eb908387324f2b575b4879cd9d7188f69c8fc9d87c901b9e2daaea4b442170"
                            .parse()
                            .unwrap(),
                    ),
                    None,
                )
                .await;
            assert!(txs.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_erc20_transfer_events_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let txs = client
                .get_erc20_token_transfer_events(
                    TokenQueryOption::ByAddress(
                        "0x4e83362442b8d1bec281594cea3050c8eb01311c".parse().unwrap(),
                    ),
                    None,
                )
                .await;
            assert!(txs.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_erc721_transfer_events_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let txs = client
                .get_erc721_token_transfer_events(
                    TokenQueryOption::ByAddressAndContract(
                        "0x6975be450864c02b4613023c2152ee0743572325".parse().unwrap(),
                        "0x06012c8cf97bead5deae237070f9587f8e7a266d".parse().unwrap(),
                    ),
                    None,
                )
                .await;
            assert!(txs.is_ok());
        })
        .await
    }

    #[tokio::test]
    #[serial]
    async fn get_mined_blocks_success() {
        run_at_least_duration(Duration::from_millis(250), async {
            let client = Client::new_from_env(Chain::Mainnet).unwrap();

            let blocks = client
                .get_mined_blocks(
                    &"0x9dd134d14d1e65f84b706d6f205cd5b1cd03a46b".parse().unwrap(),
                    None,
                    None,
                )
                .await;
            assert!(blocks.is_ok());
        })
        .await
    }
}