// 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 node_common::timestamp::MockTimestampInherentDataProvider;

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::node_builder::{

        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;

}

const RELAY_CHAIN_SLOT_DURATION_MILLIS: u64 = 6_000;

    // The nimbus import queue ONLY checks the signature correctness

    // Any other checks corresponding to the author-correctness should be done

    // in the runtime

        false,

        false,

    )

/// 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, start_bootnode_params) = 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,

        start_bootnode_params,

    )?;

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

                ),

            )),

                    RELAY_CHAIN_SLOT_DURATION_MILLIS,

                );

                // Get the mocked timestamp

                // Calculate mocked slot number

                );

                    {

                        }

                    };

                        relay_offset: 1000,

                        relay_blocks_per_para_block: 2,

                        // TODO: Recheck

                        para_blocks_per_relay_epoch: 10,

                        ),

                            );

                    };

        })?;

    }

    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)

}