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

    AssetTrapFallbackProcessor, SymbioticFallbackProcessor,

};

use crate::processors::v2::{

    CodecError, FallbackMessageProcessor, MessageExtractionError, MessageProcessorWithFallback,

};

use alloc::boxed::Box;

use alloc::format;

use alloc::string::ToString;

use core::marker::PhantomData;

use parity_scale_codec::Decode;

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

use sp_core::{Get, H160};

use sp_runtime::Weight;

use tp_bridge::symbiotic_message_processor::{

    InboundCommand, Message as SymbioticMessage, Payload as SymbioticPayload, MAGIC_BYTES,

};

use v2_processor_proc_macro::MessageProcessor;

use xcm::latest::{ExecuteXcm, InteriorLocation, NetworkId};

use xcm_executor::traits::WeightBounds;

                }

                }

            }

        }

    }

        tp_bridge::symbiotic_message_processor::Message::V1(

            InboundCommand::ReceiveValidators {

            },

        ) => {

            // It is fine to return an error here as we know that a valid symbiotic message

            // does not contain any asset so there is no need to return success here to trap assets.

            // Moreover, the failure here might indicate critical issue within runtime, so it is crucial

            // that we do not ignore it.

            )

        }

    }

/// Processes Symbiotic protocol messages for external validator set management.

///

/// This processor handles messages from the Symbiotic middleware that controls validator

/// registration and management. Messages must be encoded in `Payload::Raw(RawPayload::Symbiotic)`

/// format and originate from the authorized gateway proxy address.

///

/// # Message Validation

///

/// Strictly validates incoming messages:

/// - **Origin check**: Message must come from the configured gateway proxy address

/// - **Asset check**: Symbiotic messages cannot contain assets, ETH value, or execution fees

/// - **Magic bytes**: Payload must contain correct set of bytes to identify Symbiotic messages

///

/// # Supported Commands

///

/// Currently, processes `InboundCommand::ReceiveValidators` which:

/// - Updates the external validator set via `pallet_external_validators`

/// - Tracks validator changes by external index

/// - Returns errors on validation failures (no asset trapping needed)

///

/// # Fallback Behavior

///

/// Uses `SymbioticFallbackProcessor` which conditionally applies asset trapping:

/// - **If origin is not gateway**: Assumes user error or malicious behaviour → trap assets via `AssetTrapFallbackProcessor`

/// - **If origin is gateway**: Assumes middleware error → return error to signal the problem

///

/// Unlike `RawMessageProcessor`, this can safely return errors in case origin is gateway since valid Symbiotic messages

/// from middleware never contain assets that could be lost. And error in that case indicate critical runtime issues that

/// should not be silently ignored.

#[derive(MessageProcessor)]

pub struct SymbioticMessageProcessor<

    T,

    GatewayAddress,

    DefaultClaimer,

    EthereumNetwork,

    EthereumUniversalLocation,

    TanssiUniversalLocation,

    XcmProcessor,

    XcmWeigher,

    MaxXcmWeight,

    SetExternalValidatorsWeight,

>(

    PhantomData<(

        T,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

        SetExternalValidatorsWeight,

    )>,

);

impl<

        T,

        AccountId,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

        SetExternalValidatorsWeight,

    > MessageProcessorWithFallback<AccountId>

    for SymbioticMessageProcessor<

        T,

        GatewayAddress,

        DefaultClaimer,

        EthereumNetwork,

        EthereumUniversalLocation,

        TanssiUniversalLocation,

        XcmProcessor,

        XcmWeigher,

        MaxXcmWeight,

        SetExternalValidatorsWeight,

    >

where

    T: snowbridge_pallet_inbound_queue::Config

        + pallet_xcm::Config

        + snowbridge_pallet_system::Config

        + pallet_external_validators::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>,

    SetExternalValidatorsWeight: Get<Weight>,

{

    type Fallback = SymbioticFallbackProcessor<

        T,

        AssetTrapFallbackProcessor<

            T,

            GatewayAddress,

            DefaultClaimer,

            EthereumNetwork,

            EthereumUniversalLocation,

            TanssiUniversalLocation,

            XcmProcessor,

            XcmWeigher,

            MaxXcmWeight,

        >,

        GatewayAddress,

    >;

    type ExtractedMessage = SymbioticMessage<T>;

        // This ensures the worst case covers both the primary and fallback paths regardless of configuration.

}