vineyard

use anyhow::{Context as _, Result};

use nostr::filter::Filter;

use rusqlite::types::Value;

const DEFAULT_LIMIT: usize = 10_000;

const SELECT_EVENTS: &str = "

SELECT e.id, e.pubkey, e.created_at, e.kind, e.content, e.tags, e.sig

FROM events AS e

WHERE 1 = 1

";

const TAG_VALUES: &str = "

 AND EXISTS (

    SELECT 1

    FROM event_tags AS tag

    WHERE tag.event_id = e.id

      AND tag.tag_name = ?

      AND tag.tag_value IN (

";

pub struct EventQuery {

    pub(crate) sql: String,

    pub(crate) parameters: Vec<Value>,

    pub(crate) limit: usize,

}

impl EventQuery {

    pub(crate) fn new(filter: &Filter) -> Result<Self> {

        if filter.search.is_some() {

            anyhow::bail!("search is not supported");

        }

        let mut query = Self {

            sql: SELECT_EVENTS.to_owned(),

            parameters: Vec::new(),

            limit: filter.limit.unwrap_or(DEFAULT_LIMIT),

        };

        if let Some(ids) = filter.ids.as_ref() {

            query.add_values(

                "e.id",

                ids.iter()

                    .map(|id| Value::Blob(id.as_bytes().to_vec()))

                    .collect(),

            );

        }

        if let Some(authors) = filter.authors.as_ref() {

            query.add_values(

                "e.pubkey",

                authors

                    .iter()

                    .map(|author| Value::Blob(author.as_bytes().to_vec()))

                    .collect(),

            );

        }

        if let Some(kinds) = filter.kinds.as_ref() {

            query.add_values(

                "e.kind",

                kinds

                    .iter()

                    .map(|kind| Value::Integer(i64::from(kind.as_u16())))

                    .collect(),

            );

        }

        if let Some(since) = filter.since {

            query.add_condition(

                "e.created_at >= ?",

                Value::Integer(timestamp(since.as_secs())?),

            );

        }

        if let Some(until) = filter.until {

            query.add_condition(

                "e.created_at <= ?",

                Value::Integer(timestamp(until.as_secs())?),

            );

        }

        for (tag, values) in &filter.generic_tags {

            if values.is_empty() {

                query.exclude_all();

                break;

            }

            query.sql.push_str(TAG_VALUES);

            query.parameters.push(Value::Text(tag.to_string()));

            query.add_placeholders(values.len());

            query.sql.push_str("))");

            query

                .parameters

                .extend(values.iter().cloned().map(Value::Text));

        }

        query.sql.push_str(" ORDER BY e.created_at DESC, e.id");

        Ok(query)

    }

    fn add_values(&mut self, column: &str, values: Vec<Value>) {

        if values.is_empty() {

            self.exclude_all();

            return;

        }

        self.sql.push_str(" AND ");

        self.sql.push_str(column);

        self.sql.push_str(" IN (");

        self.add_placeholders(values.len());

        self.sql.push(')');

        self.parameters.extend(values);

    }

    fn add_condition(&mut self, condition: &str, value: Value) {

        self.sql.push_str(" AND ");

        self.sql.push_str(condition);

        self.parameters.push(value);

    }

    fn add_placeholders(&mut self, count: usize) {

        for index in 0..count {

            if index > 0 {

                self.sql.push_str(", ");

            }

            self.sql.push('?');

        }

    }

    fn exclude_all(&mut self) {

        self.sql.push_str(" AND 0");

    }

}

fn timestamp(value: u64) -> Result<i64> {

    value.try_into().context("timestamp exceeds sqlite range")

}