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

//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.

use {

    container_chain_template_simple_runtime::Hash,

    container_chain_template_simple_runtime::{opaque::Block, RuntimeApi},

    cumulus_client_cli::CollatorOptions,

    cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport,

    cumulus_client_parachain_inherent::{MockValidationDataInherentDataProvider, MockXcmConfig},

    cumulus_client_service::{prepare_node_config, ParachainHostFunctions},

    cumulus_primitives_core::{

        relay_chain::well_known_keys as RelayWellKnownKeys, CollectCollationInfo, ParaId,

    },

    nimbus_primitives::NimbusId,

    node_common::service::{ManualSealConfiguration, NodeBuilder, NodeBuilderConfig, Sealing},

    parity_scale_codec::Encode,

    polkadot_parachain_primitives::primitives::HeadData,

    polkadot_primitives::UpgradeGoAhead,

    sc_consensus::BasicQueue,

    sc_executor::WasmExecutor,

    sc_network::NetworkBackend,

    sc_service::{Configuration, TFullBackend, TFullClient, TaskManager},

    sp_api::ProvideRuntimeApi,

    sp_blockchain::HeaderBackend,

    sp_consensus_slots::{Slot, SlotDuration},

    sp_core::{Pair, H256},

    std::{sync::Arc, time::Duration},

};

type ParachainExecutor = WasmExecutor<ParachainHostFunctions>;

type ParachainClient = TFullClient<Block, RuntimeApi, ParachainExecutor>;

type ParachainBackend = TFullBackend<Block>;

type ParachainBlockImport = TParachainBlockImport<Block, Arc<ParachainClient>, ParachainBackend>;

pub struct NodeConfig;

impl NodeBuilderConfig for NodeConfig {

    type Block = Block;

    type RuntimeApi = RuntimeApi;

    type ParachainExecutor = ParachainExecutor;

}

thread_local!(static TIMESTAMP: std::cell::RefCell<u64> = const { std::cell::RefCell::new(0) });

/// Provide a mock duration starting at 0 in millisecond for timestamp inherent.

/// Each call will increment timestamp by slot_duration making Aura think time has passed.

struct MockTimestampInherentDataProvider;

#[async_trait::async_trait]

impl sp_inherents::InherentDataProvider for MockTimestampInherentDataProvider {

    async fn provide_inherent_data(

        &self,

        inherent_data: &mut sp_inherents::InherentData,

    async fn try_handle_error(

        &self,

        _identifier: &sp_inherents::InherentIdentifier,

        _error: &[u8],

        // The pallet never reports error.

}

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

#[sc_tracing::logging::prefix_logs_with("Parachain")]

pub async fn start_parachain_node<Net>(

    parachain_config: Configuration,

    polkadot_config: Configuration,

    collator_options: CollatorOptions,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

) -> sc_service::error::Result<(TaskManager, Arc<ParachainClient>)>

where

    Net: NetworkBackend<Block, Hash>,

{

    let parachain_config = prepare_node_config(parachain_config);

    // Create a `NodeBuilder` which helps setup parachain nodes common systems.

    let mut node_builder = NodeConfig::new_builder(&parachain_config, hwbench.clone())?;

    let (_, import_queue) = import_queue(&parachain_config, &node_builder);

    // Relay chain interface

    let (relay_chain_interface, _collator_key) = node_builder

        .build_relay_chain_interface(&parachain_config, polkadot_config, collator_options.clone())

        .await?;

    // Build cumulus network, allowing to access network-related services.

    let node_builder = node_builder

        .build_cumulus_network::<_, Net>(

            &parachain_config,

            para_id,

            import_queue,

            relay_chain_interface.clone(),

        )

        .await?;

    let rpc_builder = {

        let client = node_builder.client.clone();

        let transaction_pool = node_builder.transaction_pool.clone();

    };

    let node_builder = node_builder.spawn_common_tasks(parachain_config, rpc_builder)?;

    let relay_chain_slot_duration = Duration::from_secs(6);

    let node_builder = node_builder.start_full_node(

        para_id,

        relay_chain_interface.clone(),

        relay_chain_slot_duration,

    )?;

    Ok((node_builder.task_manager, node_builder.client))

}

/// Helper function to generate a crypto pair from seed

/// Start a node with the given parachain `Configuration` and relay chain `Configuration`.

///

/// This is the actual implementation that is abstract over the executor and the runtime api.

#[sc_tracing::logging::prefix_logs_with("Parachain Dev Node")]

pub async fn start_dev_node(

    parachain_config: Configuration,

    sealing: Sealing,

    para_id: ParaId,

    hwbench: Option<sc_sysinfo::HwBench>,

) -> sc_service::error::Result<TaskManager> {

    let parachain_config = prepare_node_config(parachain_config);

    // Create a `NodeBuilder` which helps setup parachain nodes common systems.

    let node_builder = NodeConfig::new_builder(&parachain_config, hwbench.clone())?;

    let (parachain_block_import, import_queue) = import_queue(&parachain_config, &node_builder);

    // Build a Substrate Network. (not cumulus since it is a dev node, it mocks

    // the relaychain)

    let mut node_builder = node_builder

        .build_substrate_network::<sc_network::NetworkWorker<_, _>>(

            &parachain_config,

            import_queue,

        )?;

    let mut command_sink = None;

    let mut xcm_senders = None;

    if parachain_config.role.is_authority() {

        let client = node_builder.client.clone();

        let (downward_xcm_sender, downward_xcm_receiver) = flume::bounded::<Vec<u8>>(100);

        let (hrmp_xcm_sender, hrmp_xcm_receiver) = flume::bounded::<(ParaId, Vec<u8>)>(100);

        xcm_senders = Some((downward_xcm_sender, hrmp_xcm_sender));

        let authorities = vec![get_aura_id_from_seed("alice")];

        command_sink = node_builder.install_manual_seal(ManualSealConfiguration {

            block_import: parachain_block_import,

            sealing,

            soft_deadline: None,

            select_chain: sc_consensus::LongestChain::new(node_builder.backend.clone()),

            consensus_data_provider: Some(Box::new(

                tc_consensus::ContainerManualSealAuraConsensusDataProvider::new(

                    SlotDuration::from_millis(

                        container_chain_template_simple_runtime::SLOT_DURATION,

                    ),

                    authorities.clone(),

                ),

            )),

                    {

                            },

                    };

                            );

        })?;

    }

    let rpc_builder = {

        let client = node_builder.client.clone();

        let transaction_pool = node_builder.transaction_pool.clone();

    };

    let node_builder = node_builder.spawn_common_tasks(parachain_config, rpc_builder)?;

    log::info!("Development Service Ready");

    Ok(node_builder.task_manager)

}