vineyard

use std::collections::HashSet;

use std::fs::read_to_string;

use std::net::SocketAddr;

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

use nostr::key::PublicKey;

use serde::Deserialize;

use tokio::sync::Semaphore;

fn default_listen() -> SocketAddr {

    SocketAddr::from(([127, 0, 0, 1], 7777))

}

fn default_database() -> PathBuf {

    PathBuf::from("vineyard.sqlite")

}

const fn default_max_connections() -> usize {

    32

}

const fn default_max_connections_per_ip() -> usize {

    8

}

const fn default_max_subscriptions() -> usize {

    16

}

const fn default_max_event_bytes() -> usize {

    2_096_896

}

const fn default_max_message_bytes() -> usize {

    2_097_152

}

const fn default_max_tags() -> usize {

    128

}

const fn default_max_filters() -> usize {

    8

}

const fn default_max_filter_bytes() -> usize {

    32_768

}

const fn default_max_query_results() -> usize {

    500

}

const fn default_max_repositories() -> usize {

    4096

}

const fn default_max_discovered_peers() -> usize {

    32

}

const fn default_max_query_bytes() -> usize {

    16_777_216

}

const fn default_events_per_minute() -> u32 {

    120

}

const fn default_queries_per_minute() -> u32 {

    120

}

const fn default_max_database_bytes() -> u64 {

    1_073_741_824

}

const fn default_min_free_bytes() -> u64 {

    67_108_864

}

const fn default_write_timeout_seconds() -> u64 {

    10

}

#[derive(Debug, Clone, Deserialize)]

#[serde(deny_unknown_fields)]

pub struct Config {

    #[serde(default = "default_listen")]

    pub listen: SocketAddr,

    pub public_url: String,

    #[serde(default = "default_database")]

    pub database: PathBuf,

    pub forge_pubkeys: Vec<String>,

    #[serde(default)]

    pub peers: Vec<Peer>,

    #[serde(default)]

    pub allow_private_discovery: bool,

    #[serde(default)]

    pub limits: Limits,

}

#[derive(Debug, Clone, Deserialize)]

#[serde(deny_unknown_fields)]

pub struct Peer {

    pub url: String,

    #[serde(default = "default_max_query_results")]

    pub query_limit: usize,

    pub rescan_from: Option<u64>,

}

#[derive(Debug, Clone, Deserialize)]

#[serde(deny_unknown_fields)]

pub struct Limits {

    #[serde(default = "default_max_repositories")]

    pub max_repositories: usize,

    #[serde(default = "default_max_discovered_peers")]

    pub max_discovered_peers: usize,

    #[serde(default = "default_max_connections")]

    pub max_connections: usize,

    #[serde(default = "default_max_connections_per_ip")]

    pub max_connections_per_ip: usize,

    #[serde(default = "default_max_subscriptions")]

    pub max_subscriptions: usize,

    #[serde(default = "default_max_event_bytes")]

    pub max_event_bytes: usize,

    #[serde(default = "default_max_message_bytes")]

    pub max_message_bytes: usize,

    #[serde(default = "default_max_tags")]

    pub max_tags: usize,

    #[serde(default = "default_max_filters")]

    pub max_filters: usize,

    #[serde(default = "default_max_filter_bytes")]

    pub max_filter_bytes: usize,

    #[serde(default = "default_max_query_results")]

    pub max_query_results: usize,

    #[serde(default = "default_max_query_bytes")]

    pub max_query_bytes: usize,

    #[serde(default = "default_events_per_minute")]

    pub events_per_minute: u32,

    #[serde(default = "default_queries_per_minute")]

    pub queries_per_minute: u32,

    #[serde(default = "default_max_database_bytes")]

    pub max_database_bytes: u64,

    #[serde(default = "default_min_free_bytes")]

    pub min_free_bytes: u64,

    #[serde(default = "default_write_timeout_seconds")]

    pub write_timeout_seconds: u64,

}

impl Default for Limits {

    fn default() -> Self {

        Self {

            max_repositories: default_max_repositories(),

            max_discovered_peers: default_max_discovered_peers(),

            max_connections: default_max_connections(),

            max_connections_per_ip: default_max_connections_per_ip(),

            max_subscriptions: default_max_subscriptions(),

            max_event_bytes: default_max_event_bytes(),

            max_message_bytes: default_max_message_bytes(),

            max_tags: default_max_tags(),

            max_filters: default_max_filters(),

            max_filter_bytes: default_max_filter_bytes(),

            max_query_results: default_max_query_results(),

            max_query_bytes: default_max_query_bytes(),

            events_per_minute: default_events_per_minute(),

            queries_per_minute: default_queries_per_minute(),

            max_database_bytes: default_max_database_bytes(),

            min_free_bytes: default_min_free_bytes(),

            write_timeout_seconds: default_write_timeout_seconds(),

        }

    }

}

impl Config {

    pub fn load(path: &Path) -> anyhow::Result<Self> {

        let text = read_to_string(path).map_err(|error| {

            anyhow::anyhow!("failed to read config {}: {error}", path.display())

        })?;

        let mut cfg: Self = toml::from_str(&text).map_err(|error| {

            anyhow::anyhow!("failed to parse config {}: {error}", path.display())

        })?;

        if cfg.database.is_relative() {

            if let Some(parent) = path.parent() {

                if !parent.as_os_str().is_empty() {

                    cfg.database = parent.join(&cfg.database);

                }

            }

        }

        cfg.validate()?;

        Ok(cfg)

    }

    pub fn validate(&self) -> anyhow::Result<()> {

        let url = relay_url(&self.public_url)

            .ok_or_else(|| anyhow::anyhow!("invalid public_url {}", self.public_url))?;

        self.forge_keys()?;

        if self.peers.len() > 16 {

            anyhow::bail!("at most 16 peer relays are supported");

        }

        let mut peers = HashSet::new();

        for peer in &self.peers {

            let peer_url = relay_url(&peer.url).ok_or_else(|| {

                anyhow::anyhow!(

                    "peer urls must be ws or wss without credentials, queries or fragments"

                )

            })?;

            if peer_url == url || !peers.insert(peer_url) {

                anyhow::bail!("peer urls must be unique and distinct from public_url");

            }

            if !(2..10000).contains(&peer.query_limit) {

                anyhow::bail!("peer query_limit must be between 2 and 9999");

            }

        }

        if self.limits.max_connections == 0

            || self.limits.max_connections_per_ip == 0

            || self.limits.max_subscriptions == 0

            || self.limits.max_event_bytes == 0

            || self.limits.max_message_bytes == 0

            || self.limits.max_tags == 0

            || self.limits.max_filters == 0

            || self.limits.max_filter_bytes == 0

            || self.limits.max_query_results == 0

            || self.limits.max_query_bytes == 0

            || self.limits.events_per_minute == 0

            || self.limits.queries_per_minute == 0

            || self.limits.max_database_bytes == 0

            || self.limits.min_free_bytes == 0

            || self.limits.write_timeout_seconds == 0

        {

            anyhow::bail!("limits must all be positive");

        }

        if self.limits.max_connections_per_ip > self.limits.max_connections {

            anyhow::bail!("max_connections_per_ip must not exceed max_connections");

        }

        let min_message = self

            .limits

            .max_event_bytes

            .checked_add(256)

            .ok_or_else(|| anyhow::anyhow!("max_event_bytes too large"))?;

        if min_message > self.limits.max_message_bytes {

            anyhow::bail!("max_message_bytes must fit max_event_bytes plus 256 bytes of overhead");

        }

        if self.limits.max_event_bytes > self.limits.max_query_bytes {

            anyhow::bail!("max_query_bytes must fit one maximum size event");

        }

        if self.limits.max_repositories == 0 || self.limits.max_repositories >= 10000 {

            anyhow::bail!("max_repositories must be between 1 and 9999");

        }

        if self.limits.max_discovered_peers == 0 || self.limits.max_discovered_peers > 256 {

            anyhow::bail!("max_discovered_peers must be between 1 and 256");

        }

        if self.limits.max_query_results >= 10000 {

            anyhow::bail!("max_query_results must be below 10000");

        }

        if self.limits.max_connections > Semaphore::MAX_PERMITS {

            anyhow::bail!("max_connections exceeds the semaphore limit");

        }

        self.limits

            .max_filter_bytes

            .checked_mul(self.limits.max_subscriptions)

            .ok_or_else(|| anyhow::anyhow!("subscription byte budget is too large"))?;

        if self.websocket_path()? == "/healthz" {

            anyhow::bail!("public_url must not use the health endpoint");

        }

        Ok(())

    }

    pub fn forge_keys(&self) -> anyhow::Result<HashSet<PublicKey>> {

        if self.forge_pubkeys.is_empty() {

            anyhow::bail!("forge_pubkeys must not be empty");

        }

        let mut set = HashSet::new();

        for raw in &self.forge_pubkeys {

            let trimmed = raw.trim();

            if trimmed.len() != 64 || !trimmed.bytes().all(|byte| byte.is_ascii_hexdigit()) {

                anyhow::bail!("invalid forge public key: {raw}");

            }

            let key: PublicKey = trimmed

                .parse()

                .map_err(|error| anyhow::anyhow!("invalid forge public key {raw}: {error}"))?;

            if !set.insert(key) {

                anyhow::bail!("duplicate forge public key: {raw}");

            }

        }

        Ok(set)

    }

    pub fn websocket_path(&self) -> anyhow::Result<String> {

        let url = url::Url::parse(&self.public_url)

            .map_err(|error| anyhow::anyhow!("invalid public_url {}: {error}", self.public_url))?;

        let path = url.path();

        if path.is_empty() {

            Ok("/".to_owned())

        } else if path.starts_with('/') {

            Ok(path.to_owned())

        } else {

            Ok(format!("/{path}"))

        }

    }

}

pub(crate) fn relay_url(raw: &str) -> Option<url::Url> {

    let url = url::Url::parse(raw).ok()?;

    if !matches!(url.scheme(), "ws" | "wss")

        || url.host_str().is_none()

        || !url.username().is_empty()

        || url.password().is_some()

        || url.query().is_some()

        || url.fragment().is_some()

    {

        return None;

    }

    Some(url)

}