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

use {

    node_common::{

        cli::{BuildSpecCmd, ExportChainSpecCmd},

        service::node_builder::Sealing,

    },

    std::path::PathBuf,

    tc_service_container_chain_spawner::cli::ContainerChainRunCmd,

};

/// Sub-commands supported by the collator.

#[derive(Debug, clap::Subcommand)]

#[allow(clippy::large_enum_variant)]

pub enum Subcommand {

    /// Build a chain specification.

    #[deprecated(

        note = "build-spec command will be removed after 1/04/2026. Use export-chain-spec command instead"

    )]

    BuildSpec(BuildSpecCmdCollator),

    /// Export the chain specification.

    ExportChainSpec(ExportChainSpecCmdCollator),

    /// Validate blocks.

    CheckBlock(sc_cli::CheckBlockCmd),

    /// Export blocks.

    ExportBlocks(sc_cli::ExportBlocksCmd),

    /// Export the state of a given block into a chain spec.

    ExportState(sc_cli::ExportStateCmd),

    /// Import blocks.

    ImportBlocks(sc_cli::ImportBlocksCmd),

    /// Revert the chain to a previous state.

    Revert(sc_cli::RevertCmd),

    /// Remove the whole chain.

    PurgeChain(cumulus_client_cli::PurgeChainCmd),

    /// Export the genesis state of the parachain.

    #[command(alias = "export-genesis-state")]

    ExportGenesisHead(cumulus_client_cli::ExportGenesisHeadCommand),

    /// Export the genesis wasm of the parachain.

    ExportGenesisWasm(ExportGenesisWasmCommand),

    /// Sub-commands concerned with benchmarking.

    /// The pallet benchmarking moved to the `pallet` sub-command.

    #[command(subcommand)]

    Benchmark(frame_benchmarking_cli::BenchmarkCmd),

    /// Key management cli utilities

    #[command(subcommand)]

    Key(KeyCmd),

    /// Precompile the WASM runtime into native code

    PrecompileWasm(sc_cli::PrecompileWasmCmd),

    /// Solochain collator mode

    SoloChain(SoloChainCmd),

}

/// Run the node is solochain mode. First serie of arguments are targeted for

/// a container chain, while the second set (after --) are targeted towards the

/// relay/orchestrator chain (the same chain in solochain mode).

#[derive(Debug, clap::Parser)]

#[group(skip)]

pub struct SoloChainCmd {

    #[command(flatten)]

    pub run: ContainerChainRunCmd,

    /// Disable automatic hardware benchmarks.

    ///

    /// By default these benchmarks are automatically ran at startup and measure

    /// the CPU speed, the memory bandwidth and the disk speed.

    ///

    /// The results are then printed out in the logs, and also sent as part of

    /// telemetry, if telemetry is enabled.

    #[arg(long)]

    pub no_hardware_benchmarks: bool,

    /// Relay chain arguments

    #[arg(raw = true)]

    pub relay_chain_args: Vec<String>,

}

#[derive(Debug, Clone, clap::Args)]

pub struct ExtraFields {

    /// List of container chain chain spec paths to add to genesis.

    #[arg(long)]

    pub add_container_chain: Option<Vec<String>>,

    /// List of container chain chain spec mocks to add to genesis.

    #[arg(long)]

    pub mock_container_chain: Option<Vec<u32>>,

    /// List of invulnerable collators to write to pallet_invulnerables genesis.

    #[arg(long)]

    pub invulnerable: Option<Vec<String>>,

    #[arg(long)]

    pub parachain_id: Option<u32>,

}

pub type BuildSpecCmdCollator = BuildSpecCmd<ExtraFields>;

pub type ExportChainSpecCmdCollator = ExportChainSpecCmd<ExtraFields>;

/// Command for exporting the genesis wasm file.

#[derive(Debug, clap::Parser)]

pub struct ExportGenesisWasmCommand {

    /// Output file name or stdout if unspecified.

    pub output: Option<PathBuf>,

    /// Write output in binary. Default is to write in hex.

    #[arg(short, long)]

    pub raw: bool,

    /// The name of the chain for that the genesis wasm file should be exported.

    #[arg(long)]

    pub chain: Option<String>,

}

#[derive(Debug, clap::Parser)]

#[group(skip)]

pub struct RunCmd {

    #[clap(flatten)]

    pub base: cumulus_client_cli::RunCmd,

    /// Enable the development service to run without a backing relay chain

    #[arg(long)]

    pub dev_service: bool,

    /// When blocks should be sealed in the dev service.

    ///

    /// Options are "instant", "manual", or timer interval in milliseconds

    #[arg(long, default_value = "instant")]

    pub sealing: Sealing,

    /// Id of the parachain this collator collates for.

    #[arg(long)]

    pub parachain_id: Option<u32>,

}

impl std::ops::Deref for RunCmd {

    type Target = cumulus_client_cli::RunCmd;

}

#[derive(Debug, clap::Subcommand)]

pub enum KeyCmd {

    #[command(flatten)]

    BaseCli(sc_cli::KeySubcommand),

}

impl KeyCmd {

    /// run the key subcommands

        }

}

#[derive(Debug, clap::Parser)]

#[command(

    propagate_version = true,

    args_conflicts_with_subcommands = true,

    subcommand_negates_reqs = true

)]

pub struct Cli {

    #[command(subcommand)]

    pub subcommand: Option<Subcommand>,

    #[command(flatten)]

    pub run: RunCmd,

    /// Disable automatic hardware benchmarks.

    ///

    /// By default these benchmarks are automatically ran at startup and measure

    /// the CPU speed, the memory bandwidth and the disk speed.

    ///

    /// The results are then printed out in the logs, and also sent as part of

    /// telemetry, if telemetry is enabled.

    #[arg(long)]

    pub no_hardware_benchmarks: bool,

    /// Optional parachain id that should be used to build chain spec.

    #[arg(long)]

    pub para_id: Option<u32>,

    /// Extra arguments, `container-args -- relay-args` or `relay-args` if no `--`

    #[arg(raw = true)]

    extra_args: Vec<String>,

}

impl Cli {

        } else {

            // Only relay chain args

        }

}