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

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

mod benchmarks;

#[cfg(test)]

mod tests;

pub mod symbiotic_message_processor;

use {

    core::marker::PhantomData,

    cumulus_primitives_core::{

        relay_chain::{AccountId, Balance},

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

        XcmHash,

    },

    ethabi::{Token, U256},

    frame_support::{

        ensure,

        pallet_prelude::{Decode, Encode, Get},

        traits::Contains,

    },

    frame_system::unique,

    parity_scale_codec::MaxEncodedLen,

    scale_info::TypeInfo,

    snowbridge_core::{

        outbound::{Fee, SendError},

        AgentId, Channel, ChannelId, ParaId,

    },

    snowbridge_pallet_outbound_queue::send_message_impl::Ticket,

    snowbridge_router_primitives::inbound::{

        ConvertMessage, ConvertMessageError, VersionedXcmMessage,

    },

    sp_core::{blake2_256, hashing, H256},

    sp_runtime::{app_crypto::sp_core, traits::Convert, RuntimeDebug},

    sp_std::vec::Vec,

};

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

// of the macro.

use sp_std::vec;

pub use {

    custom_do_process_message::{ConstantGasMeter, CustomProcessSnowbridgeMessage},

    custom_send_message::CustomSendMessage,

    xcm_executor::traits::ConvertLocation,

};

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

pub use benchmarks::*;

mod custom_do_process_message;

mod custom_send_message;

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

pub enum Command {

    // TODO: add real commands here

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

    },

        // 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 implementations of `/[`SendMessage`\]`

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

pub struct Message {

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

}

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

    }

}

pub struct MessageValidator<T: snowbridge_pallet_outbound_queue::Config>(PhantomData<T>);

pub trait ValidateMessage {

    type Ticket: TicketInfo;

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

}

impl<T: snowbridge_pallet_outbound_queue::Config> ValidateMessage for MessageValidator<T> {

    type Ticket = Ticket<T>;

        );

        // Ensure there is a registered channel we can transmit this message on

        );

        // Generate a unique message id unless one is provided

        // The whole message should not be too large

}

impl ValidateMessage for () {

    type Ticket = ();

}

/// Message which is awaiting processing in the MessageQueue pallet

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

pub struct QueuedMessage {

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

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

pub enum VersionedQueuedMessage {

}

impl From<QueuedMessage> for VersionedQueuedMessage {

}

impl From<VersionedQueuedMessage> for QueuedMessage {

}

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;

}

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

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);

    }

}