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

extern crate alloc;

use crate::processors::v2::{

    execute_xcm, fallback_message_processor::AssetTrapFallbackProcessor,

    prepare_raw_message_xcm_instructions, CodecError, ExtractedXcmConstructionInfo,

    FallbackMessageProcessor, MessageExtractionError, MessageProcessorWithFallback, RawPayload,

};

use crate::processors::v2::{reanchor_location_to_tanssi, RAW_MESSAGE_PROCESSOR_TOPIC_PREFIX};

use alloc::boxed::Box;

use alloc::string::ToString;

use core::marker::PhantomData;

use pallet_xcm::Event;

use parity_scale_codec::{Decode, DecodeLimit};

use snowbridge_inbound_queue_primitives::v2::{message::Message, MessageProcessorError, Payload};

use sp_core::{Get, H160};

use sp_runtime::DispatchError;

use sp_runtime::Weight;

use thiserror::Error;

use v2_processor_proc_macro::MessageProcessor;

use xcm::latest::{ExecuteXcm, Outcome};

use xcm::prelude::{InteriorLocation, NetworkId, VersionedXcm, Xcm};

use xcm::{IdentifyVersion, Version, MAX_XCM_DECODE_DEPTH};

use xcm_executor::traits::WeightBounds;

#[derive(Error, Debug)]

pub enum XcmDecodeError {

    #[error("Failed to decode versioned xcm message: {0}")]

    VersionedXcmDecodeError(#[from] CodecError),

    #[error("Xcm version {version} is not supported")]

    UnsupportedXcmVersion { version: Version },

}

/// Parse and strictly decode `raw` XCM bytes into a `Xcm<()>`.

{

        MAX_XCM_DECODE_DEPTH,

    )

{

            }

        }

    }

/// Processes raw XCM messages from Snowbridge V2 with automatic asset trapping fallback.

///

/// This processor handles messages containing user-provided XCM instructions encoded in the

/// `Payload::Raw(RawPayload::Xcm)` format. The workflow is:

///

/// 1. **Extract**: Decode the `VersionedXcm` from the message payload

/// 2. **Prepare**: Wrap user XCM

/// 3. **Execute**: Run the prepared XCM on Tanssi relay chain

///

/// # Fallback Behavior

///

/// Uses `AssetTrapFallbackProcessor` as fallback for unsupported message types (e.g., Symbiotic).

/// This ensures assets are never lost:

/// - If message extraction fails → fallback traps assets for claimer recovery

/// - If XCM execution fails → still returns success to prevent Ethereum revert, assets become

///   trapped and claimable

///

/// # Error Handling

///

/// Always returns success even on XCM execution errors to avoid leaving assets in limbo on

/// Ethereum. Execution errors are logged but don't cause transaction reversion. This is

/// necessary because user XCM may contain non-revertible operations (e.g., cross-chain messages).

#[derive(MessageProcessor)]

pub struct RawMessageProcessor<

    T,

    GatewayAddress,

    DefaultClaimer,

    EthereumNetwork,

    EthereumUniversalLocation,

    TanssiUniversalLocation,

    XcmProcessor,

    XcmWeigher,

    MaxXcmWeight,

>(

    PhantomData<(

        T,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

    )>,

);

impl<

        T,

        AccountId,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

    > MessageProcessorWithFallback<AccountId>

    for RawMessageProcessor<

        T,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

    >

where

    T: snowbridge_pallet_inbound_queue::Config

        + pallet_xcm::Config

        + snowbridge_pallet_system::Config,

    [u8; 32]: From<<T as frame_system::Config>::AccountId>,

    GatewayAddress: Get<H160>,

    DefaultClaimer: Get<<T as frame_system::Config>::AccountId>,

    EthereumNetwork: Get<NetworkId>,

    EthereumUniversalLocation: Get<InteriorLocation>,

    TanssiUniversalLocation: Get<InteriorLocation>,

    XcmProcessor: ExecuteXcm<<T as pallet_xcm::Config>::RuntimeCall>,

    XcmWeigher: WeightBounds<<T as pallet_xcm::Config>::RuntimeCall>,

    MaxXcmWeight: Get<Weight>,

{

    type Fallback = AssetTrapFallbackProcessor<

        T,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

    >;

    type ExtractedMessage = ExtractedXcmConstructionInfo<<T as pallet_xcm::Config>::RuntimeCall>;

        )

                location_conversion_error

            );

        )

                location_conversion_error

            );

        // Depending upon the content of raw xcm, it might be the case that it is not fully revertible

        // (i.e xcm that sends a message in another container chain and then return an error).

        // Another reason we are not returning error here as otherwise the tx will be reverted and assets will be in limbo in ethereum.

        // By returning success here, the assets will be trapped here and claimable by the claimer.

        );

                Outcome::Incomplete {

                } => {

                        instruction_error

                    );

                }

                // This branch will never be executed since current xcm executor implementation only returns

                // this Outcome when the weight limit is less than required which is already checked earlier

                // in execute_xcm.

                        instruction_error

                    );

                }

            },

                    instruction_error

                );

            }

        }

}