// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Tanssi is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>

// TODO:

// Rewrite of the following code which cause issues as Tanssi is not a parachain

// https://github.com/moondance-labs/polkadot-sdk/blob/tanssi-polkadot-stable2412/bridges/snowbridge/primitives/router/src/outbound/mod.rs#L98

use crate::{match_expression, XcmConverterError};

use alloc::vec::Vec;

use core::iter::Peekable;

use core::marker::PhantomData;

use core::slice::Iter;

use frame_support::{ensure, traits::Get};

use parity_scale_codec::{Decode, Encode};

use snowbridge_core::{AgentId, ChannelId, TokenId};

use snowbridge_outbound_queue_primitives::v1::{

    message::{Command, Message, SendMessage},

    AgentExecuteCommand,

};

use sp_core::H160;

use sp_runtime::traits::{MaybeEquivalence, TryConvert};

use xcm::prelude::*;

use xcm::{

    latest::SendError::{MissingArgument, NotApplicable},

    VersionedLocation, VersionedXcm,

};

use xcm_builder::{ensure_is_remote, InspectMessageQueues};

use xcm_executor::traits::{validate_export, ExportXcm};

pub struct EthereumBlobExporter<

    UniversalLocation,

    EthereumNetwork,

    OutboundQueue,

    ConvertAssetId,

    BridgeChannelInfo,

>(

    PhantomData<(

        UniversalLocation,

        EthereumNetwork,

        OutboundQueue,

        ConvertAssetId,

        BridgeChannelInfo,

    )>,

);

impl<UniversalLocation, EthereumNetwork, OutboundQueue, ConvertAssetId, BridgeChannelInfo> ExportXcm

    for EthereumBlobExporter<

        UniversalLocation,

        EthereumNetwork,

        OutboundQueue,

        ConvertAssetId,

        BridgeChannelInfo,

    >

where

    UniversalLocation: Get<InteriorLocation>,

    EthereumNetwork: Get<NetworkId>,

    OutboundQueue: SendMessage<Balance = u128>,

    ConvertAssetId: MaybeEquivalence<TokenId, Location>,

    BridgeChannelInfo: Get<Option<(ChannelId, AgentId)>>,

{

    type Ticket = (Vec<u8>, XcmHash);

        // Cloning destination to avoid modifying the value so subsequent exporters can use it.

        // Cloning universal_source to avoid modifying the value so subsequent exporters can use it.

        // TODO: Support source being a parachain.

        // validate the message

        // convert fee to Asset

}

pub struct XcmConverter<'a, ConvertAssetId, Call> {

    iter: Peekable<Iter<'a, Instruction<Call>>>,

    ethereum_network: NetworkId,

    agent_id: AgentId,

    _marker: PhantomData<ConvertAssetId>,

}

impl<'a, ConvertAssetId, Call> XcmConverter<'a, ConvertAssetId, Call>

where

    ConvertAssetId: MaybeEquivalence<TokenId, Location>,

{

            // Get withdraw/deposit and make native tokens create message.

        // All xcm instructions must be consumed before exit.

        use XcmConverterError::*;

        // Get the reserve assets from WithdrawAsset.

        // Check if clear origin exists and skip over it.

        // Get the fee asset item from BuyExecution or continue parsing.

            DepositAsset {

            },

        )

        // assert that the beneficiary is AccountKey20.

        )

        // Make sure there are reserved assets.

        // Check the the deposit asset filter matches what was reserved.

        {

        // We only support a single asset at a time.

        // Fees are collected on Tanssi, up front and directly from the user, to cover the

        // complete cost of the transfer. Any additional fees provided in the XCM program are

        // refunded to the beneficiary. We only validate the fee here if its provided to make sure

        // the XCM program is well formed. Another way to think about this from an XCM perspective

        // would be that the user offered to pay X amount in fees, but we charge 0 of that X amount

        // (no fee) and refund X to the user.

            // The fee asset must be the same as the reserve asset.

            Asset {

                }

                // Native ETH token

            },

        }

        // transfer amount must be greater than 0.

        // Check if there is a SetTopic and skip over it if found.

        } else {

        }

    /// Convert the xcm for Polkadot-native token from the origin chain (container chain) into the Command

    /// To match transfers of Polkadot-native tokens, we expect an input of the form:

    /// # ReserveAssetDeposited

    /// # ClearOrigin

    /// # BuyExecution

    /// # DepositAsset

    /// # SetTopic

        // TODO: This function will be used only when we start receiving tokens from containers.

        // The whole struct is copied from Snowbridge and modified for our needs, and thus function

        // will be modified in a latter PR.

        // use XcmConverterError::*;

        // // Get the reserve assets.

        // let reserve_assets = match_expression!(

        //     self.next()?,

        //     ReserveAssetDeposited(reserve_assets),

        //     reserve_assets

        // )

        // .ok_or(ReserveAssetDepositedExpected)?;

        // // Check if clear origin exists and skip over it.

        // if match_expression!(self.peek(), Ok(ClearOrigin), ()).is_some() {

        //     let _ = self.next();

        // }

        // // Get the fee asset item from BuyExecution or continue parsing.

        // let fee_asset = match_expression!(self.peek(), Ok(BuyExecution { fees, .. }), fees);

        // if fee_asset.is_some() {

        //     let _ = self.next();

        // }

        // let (deposit_assets, beneficiary) = match_expression!(

        //     self.next()?,

        //     DepositAsset {

        //         assets,

        //         beneficiary

        //     },

        //     (assets, beneficiary)

        // )

        // .ok_or(DepositAssetExpected)?;

        // // assert that the beneficiary is AccountKey20.

        // let recipient = match_expression!(

        //     beneficiary.unpack(),

        //     (0, [AccountKey20 { network, key }])

        //         if self.network_matches(network),

        //     H160(*key)

        // )

        // .ok_or(BeneficiaryResolutionFailed)?;

        // // Make sure there are reserved assets.

        // if reserve_assets.len() == 0 {

        //     return Err(NoReserveAssets);

        // }

        // // Check the the deposit asset filter matches what was reserved.

        // if reserve_assets

        //     .inner()

        //     .iter()

        //     .any(|asset| !deposit_assets.matches(asset))

        // {

        //     return Err(FilterDoesNotConsumeAllAssets);

        // }

        // // We only support a single asset at a time.

        // ensure!(reserve_assets.len() == 1, TooManyAssets);

        // let reserve_asset = reserve_assets.get(0).ok_or(AssetResolutionFailed)?;

        // // Fees are collected on the origin chain (container chain), up front and directly from the

        // // user, to cover the complete cost of the transfer. Any additional fees provided in the XCM

        // // program are refunded to the beneficiary. We only validate the fee here if its provided to

        // // make sure the XCM program is well formed. Another way to think about this from an XCM

        // // perspective would be that the user offered to pay X amount in fees, but we charge 0 of

        // // that X amount (no fee) and refund X to the user.

        // if let Some(fee_asset) = fee_asset {

        //     // The fee asset must be the same as the reserve asset.

        //     if fee_asset.id != reserve_asset.id || fee_asset.fun > reserve_asset.fun {

        //         return Err(InvalidFeeAsset);

        //     }

        // }

        // let (asset_id, amount) = match reserve_asset {

        //     Asset {

        //         id: AssetId(inner_location),

        //         fun: Fungible(amount),

        //     } => Some((inner_location.clone(), *amount)),

        //     _ => None,

        // }

        // .ok_or(AssetResolutionFailed)?;

        // // transfer amount must be greater than 0.

        // ensure!(amount > 0, ZeroAssetTransfer);

        // let token_id = TokenIdOf::convert_location(&asset_id).ok_or(InvalidAsset)?;

        // let expected_asset_id = ConvertAssetId::convert(&token_id).ok_or(InvalidAsset)?;

        // ensure!(asset_id == expected_asset_id, InvalidAsset);

        // // Check if there is a SetTopic and skip over it if found.

        // let topic_id = match_expression!(self.next()?, SetTopic(id), id).ok_or(SetTopicExpected)?;

        // Ok((

        //     Command::MintForeignToken {

        //         token_id,

        //         recipient,

        //         amount,

        //     },

        //     *topic_id,

        // ))

    }

}

pub struct SnowbrigeTokenTransferRouter<Bridges, UniversalLocation>(

    PhantomData<(Bridges, UniversalLocation)>,

);

impl<Bridges, UniversalLocation> SendXcm

    for SnowbrigeTokenTransferRouter<Bridges, UniversalLocation>

where

    Bridges: ExportXcm,

    UniversalLocation: Get<InteriorLocation>,

{

    type Ticket = Bridges::Ticket;

        // This `clone` ensures that `dest` is not consumed in any case.

        // Channel ID is ignored by the bridge which use a different type

        // validate export message

        )

}

impl<Bridge, UniversalLocation> InspectMessageQueues

    for SnowbrigeTokenTransferRouter<Bridge, UniversalLocation>

{

}

pub struct SnowbridgeChannelToAgentId<T>(PhantomData<T>);

impl<T: snowbridge_pallet_system::Config> TryConvert<ChannelId, AgentId>

    for SnowbridgeChannelToAgentId<T>

{

        };

}