Brain Juice

use axum::Json;

use serde::{Deserialize, Serialize};

use serde_json::{json, Value};

use std::io::Error;

use tracing::{debug, instrument};

#[derive(Serialize, Deserialize, Debug)]

#[serde(tag = "type")]

/// Event is the base type for different kinds of inputs and outputs for the processor. Events are

/// things like text matching requests, trigger requests, status requests, and whatever else.

/// Each type of processable request is in this enumerator

pub(crate) enum Event {

    Check(TextCount),

}

impl Event {

    pub(crate) fn process(self) -> impl Serialize {

        match self {

            Self::Check(text_count) => text_count.digest().unwrap(),

        }

    }

}

/// Consume is meant to imply an event is to be processed

trait Consume {

    /// SerializableResult is generally the data that will be serialized into the axum response body

    type SerializableResult: Serialize;

    /// collect is for gathering the data of a consumable event, like reading in local json

    fn collect(&mut self) -> &mut Self;

    /// digest is for digesting the data gathered and processing it, like counting the matches of text

    fn digest(self) -> Result<Self::SerializableResult, Error>;

}

/// Trigger is meant to imply an event that is going to take an action, such as sending a POST to a webhook

trait Trigger {

    /// SerializableResult is generally the data that will be serialized into the axum response body

    type SerializableResult: Serialize;

    /// dispatch is the action to take when this event (read action) is executed/dispatched

    fn dispatch(self) -> Result<Self::SerializableResult, Error>;

}

/// A function to give to the axum router for handling http POST requests for events

pub(crate) async fn post_event(Json(payload): Json<Event>) -> Json<Value> {

    debug!("Received payload {:?}", payload);

    let result = payload.process();

    Json(json!(result))

}

#[derive(Serialize, Deserialize, Debug)]

/// TextCount is representative of a grouping of patterns of text to check against for each message

pub(crate) struct TextCount {

    target: String,

    patterns: Vec<String>,

}

impl Consume for TextCount {

    type SerializableResult = TextCountResult;

    #[instrument]

    fn collect(&mut self) -> &mut Self {

        debug!("Collecting data for text count");

        self

    }

    #[instrument]

    fn digest(self) -> Result<Self::SerializableResult, Error> {

        // This event consumes itself and processes its associated patterns

        let mut pattern_results: Vec<PatternResult> = vec![];

        for pattern in self.patterns {

            pattern_results.push(PatternResult::new(pattern, 0))

        }

        let result = TextCountResult::new(self.target, pattern_results);

        Ok(result)

    }

}

#[derive(Serialize, Deserialize, Debug)]

/// PatternResult contains the text that was checked for each message and the amount of times it was found

pub(crate) struct PatternResult {

    text: String,

    count: i32,

}

impl PatternResult {

    /// Utility function for generating self

    fn new(text: String, count: i32) -> Self {

        Self { text, count }

    }

}

#[derive(Serialize, Deserialize, Debug)]

/// TextCountResult is the processed result of a [Check(TextCount)](Event::Check)

pub(crate) struct TextCountResult {

    target: String,

    patterns: Vec<PatternResult>,

}

impl TextCountResult {

    /// Utility function for generating self

    fn new(target: String, patterns: Vec<PatternResult>) -> Self {

        Self { target, patterns }

    }

}