// 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/>

//! Crate containing various traits used by moondance crates allowing to connect pallet

//! with each other or with mocks.

#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

#[cfg(feature = "runtime-benchmarks")]

mod benchmarks;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

use {

    alloc::vec::Vec,

    core::marker::PhantomData,

    cumulus_primitives_core::{

        relay_chain::{AccountId, Balance},

        AccountKey20, Assets, Ethereum, GlobalConsensus, Location, SendResult, SendXcm, Xcm,

        XcmHash,

    },

    ethabi::{Token, U256},

    frame_support::{

        pallet_prelude::{Decode, Encode, Get},

        traits::{Contains, EnqueueMessage},

    },

    frame_system::unique,

    parity_scale_codec::{DecodeWithMemTracking, MaxEncodedLen},

    scale_info::TypeInfo,

    snowbridge_core::{

        location::{DescribeGlobalPrefix, DescribeHere, DescribeTokenTerminal},

        AgentId, Channel, ChannelId, ParaId,

    },

    snowbridge_inbound_queue_primitives::v1::{

        ConvertMessage, ConvertMessageError, VersionedXcmMessage,

    },

    snowbridge_inbound_queue_primitives::v2::{

        ConvertMessage as ConvertMessageV2, ConvertMessageError as ConvertMessageV2Error,

        Message as MessageV2,

    },

    snowbridge_outbound_queue_primitives::{v1::Fee, SendError},

    snowbridge_pallet_outbound_queue::send_message_impl::Ticket,

    sp_core::{blake2_256, hashing, H256},

    sp_runtime::{app_crypto::sp_core, BoundedVec, RuntimeDebug},

    xcm_builder::{

        DescribeAccountId32Terminal, DescribeAllTerminal, DescribeFamily, DescribeTerminus,

        HashedDescription,

    },

};

// Separate import as rustfmt wrongly change it to `alloc::vec::self`, which is the module instead

// of the macro.

use alloc::vec;

pub use xcm_executor::traits::ConvertLocation;

#[cfg(feature = "runtime-benchmarks")]

pub use benchmarks::*;

pub mod custom_exporters;

pub mod inbound_queue;

pub mod outbound_queue;

pub use custom_exporters::*;

pub use inbound_queue::*;

pub use outbound_queue::*;

/// Means of converting an ML origin into a h256

/// We need to add DescribeAccountId32Terminal for cases in which a local user is the one sending the tokens

pub type TanssiAgentIdOf = HashedDescription<

    AgentId,

    (

        DescribeHere,

        DescribeFamily<DescribeAllTerminal>,

        DescribeGlobalPrefix<(

            DescribeTerminus,

            DescribeFamily<DescribeTokenTerminal>,

            DescribeAccountId32Terminal,

        )>,

    ),

>;

pub type TanssiTicketV1<T> = Ticket<T>;

/// The maximal length of an enqueued message, as determined by the MessageQueue pallet in v2

pub type MaxEnqueuedMessageSizeOfV2<T> =

    <<T as snowbridge_pallet_outbound_queue_v2::Config>::MessageQueue as EnqueueMessage<

        <T as snowbridge_pallet_outbound_queue_v2::Config>::AggregateMessageOrigin,

    >>::MaxMessageLen;

// We need to crate a new one for this. the ticket type

// in snowbridge v2 is tied to their commands (unlike v1, which only asked for a set of bytes)

// therefore we create our own structure

#[derive(Encode, Decode, TypeInfo, Clone, RuntimeDebug)]

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct TanssiTicketV2<T>

where

    T: snowbridge_pallet_outbound_queue_v2::Config,

{

    /// Origin

    pub origin: H256,

    /// ID

    pub id: H256,

    /// Fee

    pub fee: u128,

    /// Commands

    /// TODO: change to bounded

    /// I cannot change it to bounded right now because I need a cherry-pick in polkadot-sdk

    /// will leave it as a const for now, it should be  pub const MessageQueueHeapSize: u32 = 32 * 1024  - the size of a u32;

    /// since it's for now not going to be used, I will leave it to 32**102

    pub message: BoundedVec<u8, MaxEnqueuedMessageSizeOfV2<T>>,

}

// A versioned ticket that will allow us to route between v1 and v2 processors

#[derive(Encode, Decode, TypeInfo, Clone, RuntimeDebug)]

#[cfg_attr(feature = "std", derive(PartialEq))]

pub enum VersionedTanssiTicket<T>

where

    T: snowbridge_pallet_outbound_queue_v2::Config,

    T: snowbridge_pallet_outbound_queue::Config,

{

    V1(TanssiTicketV1<T>),

    V2(TanssiTicketV2<T>),

}

impl<T> From<TanssiTicketV1<T>> for VersionedTanssiTicket<T>

where

    T: snowbridge_pallet_outbound_queue_v2::Config,

    T: snowbridge_pallet_outbound_queue::Config,

{

}

impl<T> From<TanssiTicketV2<T>> for VersionedTanssiTicket<T>

where

    T: snowbridge_pallet_outbound_queue_v2::Config,

    T: snowbridge_pallet_outbound_queue::Config,

{

}

#[derive(Clone, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, PartialEq)]

pub struct SlashData {

    pub encoded_validator_id: Vec<u8>,

    pub slash_fraction: u32,

    pub external_idx: u64,

}

/// A command which is executable by the Gateway contract on Ethereum

#[derive(Clone, Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, PartialEq)]

pub enum Command {

    // TODO: add real commands here

    Test(Vec<u8>),

    ReportRewards {

        // external identifier for validators

        external_idx: u64,

        // index of the era we are sending info of

        era_index: u32,

        // total_points for the era

        total_points: u128,

        // new tokens inflated during the era

        tokens_inflated: u128,

        // merkle root of vec![(validatorId, rewardPoints)]

        rewards_merkle_root: H256,

        // the token id in which we need to mint

        token_id: H256,

    },

    ReportSlashes {

        // index of the era we are sending info of

        era_index: u32,

        // vec of `SlashData`

        slashes: Vec<SlashData>,

    },

}

impl Command {

    /// Compute the enum variant index

            // Starting from 32 to keep compatibility with Snowbridge Command enum

        }

    /// ABI-encode the Command.

            }

            Command::ReportRewards {

            } => {

            }

            }

        }

}

// A message which can be accepted by our custom implementations of `/[`SendMessage`\]`

// This message is the COMMON structure to be passed to both V1 and V2 processors

// the processors will later process it in whatever format the outbound queues expect

#[derive(Encode, Decode, TypeInfo, Clone, RuntimeDebug)]

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct TanssiMessage {

    /// ID for this message. One will be automatically generated if not provided.

    ///

    /// When this message is created from an XCM message, the ID should be extracted

    /// from the `SetTopic` instruction.

    ///

    /// The ID plays no role in bridge consensus, and is purely meant for message tracing.

    pub id: Option<H256>,

    /// The message channel ID

    pub channel_id: ChannelId,

    /// The stable ID for a receiving gateway contract

    pub command: Command,

}

pub trait TicketInfo {

    fn message_id(&self) -> H256;

}

impl TicketInfo for () {

}

#[cfg(not(feature = "runtime-benchmarks"))]

impl<T: snowbridge_pallet_outbound_queue::Config> TicketInfo for Ticket<T> {

}

#[cfg(not(feature = "runtime-benchmarks"))]

impl<T: snowbridge_pallet_outbound_queue_v2::Config> TicketInfo for TanssiTicketV2<T> {

}

#[cfg(not(feature = "runtime-benchmarks"))]

impl<T: snowbridge_pallet_outbound_queue::Config + snowbridge_pallet_outbound_queue_v2::Config>

    TicketInfo for VersionedTanssiTicket<T>

{

        }

}

// Benchmarks check message_id so it must be deterministic.

#[cfg(feature = "runtime-benchmarks")]

impl<T: snowbridge_pallet_outbound_queue::Config> TicketInfo for Ticket<T> {

    fn message_id(&self) -> H256 {

        H256::default()

    }

}

// Benchmarks check message_id so it must be deterministic.

#[cfg(feature = "runtime-benchmarks")]

impl<T: snowbridge_pallet_outbound_queue_v2::Config> TicketInfo for TanssiTicketV2<T> {

    fn message_id(&self) -> H256 {

        H256::default()

    }

}

// Benchmarks check message_id so it must be deterministic.

#[cfg(feature = "runtime-benchmarks")]

impl<T: snowbridge_pallet_outbound_queue::Config + snowbridge_pallet_outbound_queue_v2::Config>

    TicketInfo for VersionedTanssiTicket<T>

{

    fn message_id(&self) -> H256 {

        H256::default()

    }

}

// Our own implementation of validating a tanssiMessage

pub trait ValidateMessage {

    type Ticket: TicketInfo;

    fn validate(message: &TanssiMessage) -> Result<(Self::Ticket, Fee<u64>), SendError>;

}

impl ValidateMessage for () {

    type Ticket = ();

}

/// A tanssi message which is awaiting processing in the MessageQueue pallet

#[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)]

#[cfg_attr(feature = "std", derive(PartialEq))]

pub struct QueuedTanssiMessage {

    /// Message ID

    pub id: H256,

    /// Channel ID

    pub channel_id: ChannelId,

    /// Command to execute in the Gateway contract

    pub command: Command,

}

/// Enqueued outbound messages need to be versioned to prevent data corruption

/// or loss after forkless runtime upgrades

#[derive(Encode, Decode, TypeInfo, Clone, RuntimeDebug)]

#[cfg_attr(feature = "std", derive(PartialEq))]

pub enum VersionedQueuedTanssiMessage {

    V1(QueuedTanssiMessage),

}

impl From<QueuedTanssiMessage> for VersionedQueuedTanssiMessage {

}

impl From<VersionedQueuedTanssiMessage> for QueuedTanssiMessage {

        }

}

// Our own implementation of deliver message.

// this one takes a ticket and delivers it

// TODO: why did we separate these 2 (validate and deliver)?

pub trait DeliverMessage {

    type Ticket;

    fn deliver(ticket: Self::Ticket) -> Result<H256, SendError>;

}

/// Dummy router for xcm messages coming from ethereum

pub struct DoNothingRouter;

impl SendXcm for DoNothingRouter {

    type Ticket = Xcm<()>;

}

/// Dummy message converter to convert message to Xcm

pub struct DoNothingConvertMessage;

impl ConvertMessage for DoNothingConvertMessage {

    type Balance = Balance;

    type AccountId = AccountId;

}

impl ConvertMessageV2 for DoNothingConvertMessage {

        // TODO: figure out what to do here

}

// This is a variation of the converter found here:

// https://github.com/paritytech/polkadot-sdk/blob/711e6ff33373bc08b026446ce19b73920bfe068c/bridges/snowbridge/primitives/router/src/inbound/mod.rs#L467

//

// Upstream converter only works for parachains (parents 2) while we to use it in tanssi solo-chain

// (parents 1).

pub struct EthereumLocationsConverterFor<AccountId>(PhantomData<AccountId>);

impl<AccountId> ConvertLocation<AccountId> for EthereumLocationsConverterFor<AccountId>

where

    AccountId: From<[u8; 32]> + Clone,

{

            }

            }

        }

}

impl<AccountId> EthereumLocationsConverterFor<AccountId> {

}

/// Information of a recently created channel.

#[derive(

    Encode, Decode, DecodeWithMemTracking, RuntimeDebug, TypeInfo, Clone, PartialEq, MaxEncodedLen,

)]

pub struct ChannelInfo {

    pub channel_id: ChannelId,

    pub para_id: ParaId,

    pub agent_id: AgentId,

}

/// Trait to manage channel creation inside EthereumSystem pallet.

pub trait EthereumSystemChannelManager {

    fn create_channel(channel_id: ChannelId, agent_id: AgentId, para_id: ParaId) -> ChannelInfo;

}

/// Implementation struct for EthereumSystemChannelManager trait.

pub struct EthereumSystemHandler<Runtime>(PhantomData<Runtime>);

impl<Runtime> EthereumSystemChannelManager for EthereumSystemHandler<Runtime>

where

    Runtime: snowbridge_pallet_system::Config,

{

        } else {

        }

}

/// Helper struct to set up token and channel characteristics needed for EthereumTokenTransfers

/// pallet benchmarks.

#[cfg(feature = "runtime-benchmarks")]

pub struct EthereumTokenTransfersBenchHelper<Runtime>(PhantomData<Runtime>);

#[cfg(feature = "runtime-benchmarks")]

impl<Runtime> crate::TokenChannelSetterBenchmarkHelperTrait

    for EthereumTokenTransfersBenchHelper<Runtime>

where

    Runtime: snowbridge_pallet_system::Config,

{

    fn set_up_token(location: Location, token_id: snowbridge_core::TokenId) {

        snowbridge_pallet_system::ForeignToNativeId::<Runtime>::insert(token_id, &location);

        snowbridge_pallet_system::NativeToForeignId::<Runtime>::insert(&location, token_id);

    }

    fn set_up_channel(channel_id: ChannelId, para_id: ParaId, agent_id: AgentId) {

        let channel = Channel { agent_id, para_id };

        snowbridge_pallet_system::Agents::<Runtime>::insert(agent_id, ());

        snowbridge_pallet_system::Channels::<Runtime>::insert(channel_id, channel);

    }

}