//! Entry point of a Tor relay that is the [`TorRelay`] objects

use std::net::SocketAddr;

use std::path::{Path, PathBuf};

use std::sync::{Arc, Weak};

use anyhow::Context;

use hickory_net::runtime::TokioRuntimeProvider;

use hickory_resolver::{Resolver, ResolverBuilder};

use tokio::task::JoinSet;

use tracing::debug;

#[cfg(unix)]

use tracing::warn;

use fs_mistrust::Mistrust;

use tor_basic_utils::iter_join;

use tor_cell::relaycell::RelayCmd;

use tor_chanmgr::{ChanMgr, ChanMgrConfig, Dormancy};

use tor_config_path::CfgPathResolver;

use tor_dircommon::authority::AuthorityContacts;

use tor_dircommon::config::{DirTolerance, DownloadScheduleConfig};

use tor_dirmgr::{DirMgrConfig, DirPlugin};

use tor_dirserver::mirror::{DirMirror, DirMirrorWithBackend};

use tor_keymgr::{ArtiNativeKeystore, KeyMgr, KeyMgrBuilder};

use tor_memquota::MemoryQuotaTracker;

use tor_netdir::params::NetParameters;

use tor_persist::state_dir::StateDirectory;

use tor_persist::{FsStateMgr, StateMgr};

use tor_proto::relay::{CircuitIncomingStreamReceiver, CreateRequestHandler};

use tor_rtcompat::{DynTimeProvider, NetStreamProvider, Runtime};

use crate::client::RelayClient;

use crate::config::{DnsConfig, TorRelayConfig};

use crate::stream::RequestFilter;

use crate::stream::dns::resolver::DnsResolverReactor;

use crate::tasks::channel::build_circ_net_params;

use crate::tasks::crypto::InitKeyMaterial;

use futures::channel::mpsc;

// TODO(relay): this is in the client module, but not client-specific

use tor_proto::client::stream::DataStream;

/// An initialized but unbootstrapped relay.

///

/// This intentionally does not have access to the runtime to prevent it from doing network io.

///

/// The idea is that we can build up the relay's components in an `InertTorRelay` without a runtime,

/// and then call `init()` on it and provide a runtime to turn it into a network-capable relay.

/// This gives us two advantages:

///

/// - We can initialize the internal data structures in the `InertTorRelay` (load the keystores,

///   configure memquota, etc), which leaves `TorRelay` to just "running" the relay (bootstrapping,

///   setting up listening sockets, etc). We don't need to combine the initialization and "running

///   the relay" all within the same object.

/// - We will likely want to share some of arti's key management subcommands in the future.

///   arti-client has an `InertTorClient` which is used so that arti subcommands can access the

///   keystore. If we do a similar thing here in arti-relay in the future, it might be nice to have

///   an `InertTorRelay` which has these internal data structures, but doesn't need a runtime or

///   have any networking capabilities.

///

/// Time will tell if this ends up being a bad design decision in practice, and we can always change

/// it later.

pub(crate) struct InertTorRelay {

    /// The configuration options for the relay.

    config: TorRelayConfig,

    /// The configuration options for the client's directory manager.

    dirmgr_config: DirMgrConfig,

    /// Path resolver for expanding variables in [`CfgPath`](tor_config_path::CfgPath)s.

    #[expect(unused)] // TODO RELAY remove

    path_resolver: CfgPathResolver,

    /// State directory path.

    ///

    /// The [`StateDirectory`] stored in `state_dir` doesn't seem to have a way of getting the state

    /// directory path, so we need to store a copy of the path here.

    #[expect(unused)] // TODO RELAY remove

    state_path: PathBuf,

    /// Relay's state directory.

    #[expect(unused)] // TODO RELAY remove

    state_dir: StateDirectory,

    /// Location on disk where we store persistent data.

    state_mgr: FsStateMgr,

    /// Key manager.

    keymgr: KeyMgr,

}

impl InertTorRelay {

    /// Create a new Tor relay with the given configuration.

        // Try to take state ownership early, so we'll know if we have it.

        // Note that this `try_lock()` may return `Ok` even if we can't acquire the lock.

        // (At this point we don't yet care if we have it.)

    /// Connect the [`InertTorRelay`] to the Tor network.

        // Attempt to generate any missing keys/cert from the KeyMgr.

    /// Create the [key manager](KeyMgr).

        // Should only log fs paths at debug level or lower,

        // unless they're part of a diagnostic message.

        // TODO: support C-tor keystore

}

/// Represent an active Relay on the Tor network.

pub(crate) struct TorRelay<R: Runtime> {

    /// Asynchronous runtime object.

    runtime: R,

    /// Memory quota tracker.

    #[expect(unused)] // TODO RELAY remove

    memquota: Arc<MemoryQuotaTracker>,

    /// A "client" used by relays to construct circuits.

    client: RelayClient<R>,

    /// The directory authorities that were either configured or the compiled-in defaults.

    ///

    /// We keep a copy here so we can pass it to the descriptor publisher task. These are not

    /// exposed by a [`tor_dirmgr::DirProvider`] hence why we keep that copy from the config.

    authorities: AuthorityContacts,

    /// The directory mirror object, used for handling BEGIN_DIR.

    dir_mirror: DirMirrorWithBackend<DirPlugin>,

    /// Channel manager, used by circuits etc.

    chanmgr: Arc<ChanMgr<R>>,

    /// Handles CREATE* requests on channels.

    ///

    /// Given to the [`ChanMgr`],

    /// which gives it to each channel.

    /// We can access this handler directly to update consensus parameters or keys.

    create_request_handler: Arc<CreateRequestHandler>,

    /// The receiver for the [`Stream`](futures::Stream)s of `IncomingStream` of all circuits.

    ///

    /// Receives one [`Stream`](futures::Stream) (of tor streams) per circuit.

    /// Each of these is handled in a new task.

    circuit_stream_rx: CircuitIncomingStreamReceiver,

    /// See [`InertTorRelay::keymgr`].

    keymgr: KeyMgr,

    /// Listening OR ports.

    or_listeners: Vec<<R as NetStreamProvider<SocketAddr>>::Listener>,

    /// The hickory stub resolver, used for building the DNS resolver reactor.

    //

    // TODO(relay): this should be optional, and only set to Some

    // if we're configured to run as an exit.

    //

    // Right now, because there is no exit config,

    // arti-relay unconditionally spawns the DNS resolver task,

    // and unconditionally accepts all RESOLVE.

    resolver: Arc<Resolver<TokioRuntimeProvider>>,

}

impl<R: Runtime> TorRelay<R> {

    /// Create a new Tor relay with the given [`runtime`][tor_rtcompat].

    ///

    /// We use this to initialize components, open sockets, etc.

    /// Doing work with these components should happen in [`TorRelay::run()`].

    ///

    /// Expected to be called from [`InertTorRelay::init()`].

        // Init the channel manager.

                // TODO: It seems wrong to start with the compiled-in defaults when we might have

                // a newer network status on disk that would provide a better initial value,

                // but `TorClient` does this too so let's not worry about it.

            )

        );

        // Init the relay's client.

        )

        // Circuit-related network status parameters.

        // TODO(relay): add exit configuration, and update this to reject BEGIN and RESOLVE

        // if we are not configured to run as an exit

        // A handler that will process CREATE* requests on channels.

        );

        // Configure the channel manager to handle CREATE* requests.

        //

        // We do this once, and can later update its network parameters and keys using the

        // `Arc` handle that we store.

        // The `ChanMgr` will hold an `Arc<CreateRequestHandler>` and

        // the `CreateRequestHandler` will hold a `Weak<ChanMgr>`.

        //

        // We could technically do something fancier by creating the `ChanMgr` and handler

        // inside an `Arc::new_cyclic()` and pass the handler as part of the `ChanMgrConfig`,

        // but the code becomes a mess.

        // We don't use any custom options on the listening socket.

        // An iterator of `listen()` futures with some extra error handling.

                // If we don't support the address family (typically IPv6), only warn.

                #[cfg(unix)]

                    } else {

                        // If we got `EAFNOSUPPORT` for a non-IPv6 address, then warn louder.

                    }

                }

                }

            }

        // We await the futures sequentially rather than with something like `join_all` to make

        // errors more reproducible.

                };

            }

        };

        // Typically we would have returned with an error if we failed to listen on an address,

        // but we ignore `EAFNOSUPPORT` errors above, so it's possible that all failed with

        // `EAFNOSUPPORT` and we ended up here.

        // TODO DIRMIRROR: Need a config for the DirMirror and should be same as our

        // TorRelay one.

        // TODO: This is temporary until the directory mirror has support for downloading documents.

    /// Run the actual relay.

    ///

    /// This only returns if something has gone wrong.

    /// Otherwise it runs forever.

        // Channel housekeeping task.

        });

        // Update the CREATE* request handler when there are new network parameters.

        });

        // Listen for new Tor (OR) connections.

                // TODO: Should we give all tasks a `start` method?

        });

        // TODO DIRMIRROR: The buffer size here was picked mostly arbitrarily

        // (on my new and not-very-busy relay, I noticed bursts of ~5000 BEGIN_DIR requests per second,

        // but I'm not sure how representative this is).

        //

        // We may be able to make this buffer even smaller, assuming the consumer (i.e. DirMirror)

        // reads from it quickly enough (presumably it will read from this in a loop,

        // dispatching each request to a new task?)

        #[allow(clippy::disallowed_methods)]

        // Spawn a directory mirror server task, if we are a dir cache.

            // TODO DIRMIRROR: it would be nicer if serve() returned

            // Result<Void, _> to statically prove that it indeed never

            // returns with a non-error.

            // Plus, if we do that, we can simplify this invocation,

            // because we won't need the anyhow! error below.

        // TODO(relay): enable DoT

        //

        // TODO(relay): disable hickory's internal cache

        // (this will involve patching hickory to make its moka dependency optional)

        //

        // Note: the hickory resolver spawns various background tasks

        // Spawn the DNS reactor

        //

        // TODO(relay): only spawn this if we're configured to run as an exit

        // Listen for new Tor streams

            // TODO: Should we give all tasks a `start` method?

            ),

        );

        // Channel used to ask the descriptor publisher to rebuild and re-publish the descriptor.

        // Start the crypto task.

        });

        // Build and publish the relay's own descriptor.

                )

        });

        // Launch client tasks.

        //

        // We need to hold on to these handles until the relay stops, otherwise dropping these

        // handles would stop the background tasks.

        //

        // These are `tor_rtcompat::scheduler::TaskHandle`s, which don't notify us if they

        // stop/crash.

        //

        // TODO: Whose responsibility is it to ensure that these background tasks don't crash?

        // Should we have a way of monitoring these tasks? Or should the circuit manager re-launch

        // crashed tasks?

        // TODO: More tasks will be spawned here.

        // Now that background tasks are started, bootstrap the client.

        // We block until facism is erradicated or a task ends which means the relay will shutdown

        // and facism will have one more chance.

        // We can never get here since a `Void` cannot be constructed.

}

/// Build the hickory resolver, configuring it using

/// the settings from our [`DnsConfig`].

    // Set the hickory's internal cache size to 0

    // (we will be implementing our own cache separately)

    // Unconditionally enable case randomization,

    // equivalent to C Tor's ServerDNSRandomizeCase.

/// Prepare the hickory resolver builder, using the settings from

/// our [`DnsConfig`].

#[cfg(all(unix, not(any(target_os = "android", target_vendor = "apple"))))]

    use hickory_resolver::system_conf::parse_resolv_conf;

        // Setting the options like this is a bit funky,

        // but hickory doesn't have any other API for setting them

    } else {

    };

/// Prepare the hickory resolver builder, using the settings from

/// our [`DnsConfig`](crate::config::DnsConfig).

///

// Note: currently this returns a default-initialized hickory resolver,

// because all of the DnsConfig options we have today are unavailable

// on these platforms.

#[cfg(not(all(unix, not(any(target_os = "android", target_vendor = "apple")))))]

fn prepare_hickory_builder(

    config: &TorRelayConfig,

) -> anyhow::Result<ResolverBuilder<TokioRuntimeProvider>> {

    // We can't use resolv_conf on this platform,

    // but we deconstruct DnsConfig here to make sure that

    // if we add new fields, this will fail to compile,

    // reminding us to handle them here

    let DnsConfig { resolv_conf: _ } = &config.relay.dns;

    Ok(Resolver::builder_tokio()?)

}