jelq

use std::{sync::LazyLock, time::SystemTime};

use axum::http::{StatusCode, header};

use serde_json::{Value, json};

use super::{

    Cause, Floor, Item, Outcome, Run,

    balance::{

        EXAGGERATION, MEDITATION_ODDS, PATIENCE, PRINTABLE_RULER, RULER_SHAME, THREAD_READS,

        ULI_ODDS,

    },

    credentials::{Scheme, parse_credentials},

    measure::{exaggeration, honest},

};

use crate::{headers::X_FORUM_NOTE, problem::Problem};

pub const FORUM_THREAD: &str = "/forum/threads/2009";

pub const ELDER_LAST_MODIFIED: &str = "Sun, 14 Jun 2009 03:12:00 GMT";

static ELDER_POSTED: LazyLock<SystemTime> = LazyLock::new(|| {

    httpdate::parse_http_date(ELDER_LAST_MODIFIED).expect("the Elder's date is a valid HTTP-date")

});

const SPREADSHEET: &str = "\

date,length,girth,technique,notes,honest?

2007-01-03,7.50,5.50,wet,baseline,no

2007-06-11,7.50,5.50,wet,feeling fuller,no

2008-01-02,7.50,5.50,dry,new routine,no

2008-09-19,7.50,5.50,uli,PUT is idempotent. do not use PUT.,no

2009-06-14,7.50,5.50,wet,progress is slow but real,no

";

fn thread(detail: Option<&str>) -> Outcome {

    let mut body = forum_thread();

    if let Some(detail) = detail {

        body["detail"] = json!(detail);

    }

    Outcome::json(StatusCode::OK, body).header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED)

}

pub fn forum_thread() -> Value {

    json!({

        "title": "The definitive jelqing FAQ (updated 2009)",

        "posts": [

            { "author": "TheElder", "body": "Warm up. Always warm up. A cold jelq is a 412 waiting to happen." },

            { "author": "TheElder", "body": "Keep EQ between 50 and 70. Above 70 you are gambling. Above 90 you are a cautionary tale." },

            { "author": "newbie_2009", "body": "everyone keeps saying uli. who is uli" },

            { "author": "TheElder", "body": "uli was a member here. He posted the technique in 2001 and never posted again. Some say he ascended. The search function says his account is gone." },

            { "author": "TheElder", "body": "We do not say his name in vain. We say it in girth." },

            { "author": "newbie_2009", "body": "I have been sending PUT for three weeks and nothing has changed." },

            { "author": "TheElder", "body": "PUT is idempotent. Read the spec." },

            { "author": "TheElder", "body": "Members verify with a Ruler. Proxy-Authorization, inches, no rounding up. We can tell." },

            { "author": "newbie_2009", "body": "cant i just take off what i tell people. everyone adds an inch and a half" },

            { "author": "TheElder", "body": "Everyone adds a different amount. That is why there is a Ruler." },

            { "author": "throwaway_77", "body": "my doctor said i was normal. i didnt believe him. i still dont know what he meant by bearer" },

            { "author": "TheElder", "body": "My numbers are in my spreadsheet. They have not changed since 2009. Nothing about me has changed since 2009." },

        ],

    })

}

fn verification(detail: &str) -> Problem {

    Problem::new(

        StatusCode::PROXY_AUTHENTICATION_REQUIRED,

        "verification-required",

        detail,

    )

    .header(header::PROXY_AUTHENTICATE, "Ruler realm=\"forum\"")

}

/// The browser tab that opens on turn 10.

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Story {

    Unopened,

    Pending,

    ReadForum,

    ClosedTab,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Branch {

    Forum,

    CloseTab,

}

impl Branch {

    pub fn slug(self) -> &'static str {

        match self {

            Self::Forum => "forum",

            Self::CloseTab => "close-tab",

        }

    }

}

impl std::str::FromStr for Branch {

    type Err = ();

    fn from_str(slug: &str) -> Result<Self, ()> {

        [Self::Forum, Self::CloseTab]

            .into_iter()

            .find(|branch| branch.slug() == slug)

            .ok_or(())

    }

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Elder {

    Unverified { strikes: u8 },

    Verified,

    Beaten,

}

/// The run's life online, from the tab on turn 10 to the footage the neighbour took.

pub struct Online {

    pub(crate) story: Story,

    pub(crate) meditation_taught: bool,

    pub(crate) uli_taught: bool,

    pub(crate) elder: Elder,

    pub(crate) filmed_at: Option<SystemTime>,

}

impl Default for Online {

    fn default() -> Self {

        Self {

            story: Story::Unopened,

            meditation_taught: false,

            uli_taught: false,

            elder: Elder::Unverified { strikes: 0 },

            filmed_at: None,

        }

    }

}

impl Run {

    pub(super) fn branch_offer(&self) -> Outcome {

        let forum = self.path(&format!("/branches/{}", Branch::Forum.slug()));

        let close = self.path(&format!("/branches/{}", Branch::CloseTab.slug()));

        Outcome::json(

            StatusCode::MULTIPLE_CHOICES,

            json!({

                "detail": "A browser tab is open. It has been open for some time.",

                "choices": [

                    { "href": forum, "method": "POST", "title": "Read the forum" },

                    { "href": close, "method": "POST", "title": "Close the tab" },

                ],

            }),

        )

        .header(

            header::LINK,

            format!(

                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\"; allow=\"POST\", <{close}>; rel=\"alternate\"; title=\"Close the tab\"; allow=\"POST\""

            ),

        )

    }

    pub fn choose(&mut self, choice: Branch) -> Result<Outcome, Problem> {

        if self.online.story != Story::Pending {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "no-decision-pending",

                "There is no decision pending.",

            ));

        }

        let (story, location, detail) = match choice {

            Branch::Forum => {

                self.standing.shame += 3;

                let detail = if self.learn_meditation() {

                    "The thread is from 2009. A technique called uli is discussed at length. Further down, someone explains how to breathe, and you write it down."

                } else {

                    "The thread is from 2009. A technique called uli is discussed at length."

                };

                (Story::ReadForum, self.path("/techniques"), detail)

            }

            Branch::CloseTab => {

                self.standing.suspicion = 0;

                (

                    Story::ClosedTab,

                    self.path(""),

                    "The tab is closed. Nobody saw it.",

                )

            }

        };

        self.online.story = story;

        self.touch();

        Ok(

            Outcome::json(StatusCode::SEE_OTHER, json!({ "detail": detail }))

                .header(header::LOCATION, location),

        )

    }

    /// Re-reading is free. Each floor gets a couple of live reads that may surface the reply,

    /// after which the forum is down and the browser serves what it kept.

    pub fn read_thread(&mut self) -> Result<Outcome, Problem> {

        if !self.thread_reachable() {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "no-thread",

                "There is no thread. Nobody has mentioned a forum yet.",

            ));

        }

        if self.online.story == Story::Pending {

            return Ok(thread(None));

        }

        self.end_kitchen_visit();

        let rulerless = self.floor == Floor::Forum && !self.items.kit.ruler;

        if self.online.uli_taught && !rulerless {

            return Ok(thread(None));

        }

        if self.here.thread_rolls >= THREAD_READS {

            let age = SystemTime::now()

                .duration_since(*ELDER_POSTED)

                .map_or(0, |age| age.as_secs());

            return Ok(thread(None)

                .header(header::AGE, age.to_string())

                .header(header::WARNING, r#"112 - "Disconnected operation""#));

        }

        self.here.thread_rolls += 1;

        self.touch();

        if rulerless

            && self.chance(

                self.decision(

                    "printable-ruler",

                    "Does this read surface a member's printable ruler?",

                ),

                PRINTABLE_RULER,

            )

        {

            self.items.grant(Item::Ruler);

            self.standing.shame += RULER_SHAME;

            return Ok(thread(Some(

                "A member has attached a printable ruler. Print at 100%. Do not scale to fit. You now know.",

            ))

            .header(header::LOCATION, self.path("/inventory/ruler")));

        }

        if self.online.uli_taught {

            return Ok(thread(None));

        }

        let detail = if !self.online.meditation_taught {

            if !self.learn_meditation() {

                return Ok(thread(None));

            }

            "Between two arguments about pumps, a reply explains how to breathe. In through the nose, out through the mouth. You write it down."

        } else {

            if !self.chance(

                self.decision(

                    "teach-uli",

                    "Does this read finally surface the 2009 reply that teaches uli?",

                ),

                ULI_ODDS,

            ) {

                return Ok(thread(None));

            }

            self.online.uli_taught = true;

            "Past the necroposting, a reply from TheElder lays out the technique. Uli. The full routine. You write it down before the tab can lose it."

        };

        Ok(thread(Some(detail)))

    }

    fn learn_meditation(&mut self) -> bool {

        let taught = self.chance(

            self.decision(

                "teach-meditation",

                "Does the thread surface the reply that teaches the breathing technique?",

            ),

            MEDITATION_ODDS,

        );

        self.online.meditation_taught |= taught;

        taught

    }

    fn elder_strike(&mut self, problem: Problem) -> Problem {

        self.touch();

        let Elder::Unverified { strikes } = &mut self.online.elder else {

            return problem;

        };

        *strikes += 1;

        if *strikes < PATIENCE {

            return problem;

        }

        self.end(Cause::Banned)

    }

    /// Failed verification counts toward a ban even on GET, the way repeated bad credentials lock an account.

    fn verify_member(&mut self, proxy_authorization: Option<&str>) -> Result<(), Problem> {

        if !matches!(self.online.elder, Elder::Unverified { .. }) {

            return Ok(());

        }

        let Some(credentials) = proxy_authorization else {

            return Err(verification("The forum requires verification."));

        };

        let Some(claimed) =

            parse_credentials(credentials, Scheme::Ruler).and_then(|v| v.parse::<f64>().ok())

        else {

            return Err(verification("The forum requires verification, in inches."));

        };

        let actual = self.current_length();

        if claimed >= actual + EXAGGERATION {

            self.standing.shame += 2;

            return Err(self.elder_strike(exaggeration()));

        }

        if !honest(claimed, actual) {

            self.standing.shame += 1;

            let failed = verification("Verification failed. The forum can tell.");

            if self.girth_respected() {

                return Err(failed.header(

                    X_FORUM_NOTE,

                    "The mods have let this one go. Girth is also a dimension.",

                ));

            }

            return Err(self.elder_strike(failed));

        }

        self.online.elder = Elder::Verified;

        self.touch();

        Ok(())

    }

    pub fn elder(

        &mut self,

        proxy_authorization: Option<&str>,

        if_modified_since: Option<&str>,

    ) -> Result<Outcome, Problem> {

        if self.floor != Floor::Forum {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "elder-absent",

                "The Elder only posts on the forum.",

            ));

        }

        self.verify_member(proxy_authorization)?;

        let current = if_modified_since

            .and_then(|d| httpdate::parse_http_date(d).ok())

            .is_some_and(|since| since >= *ELDER_POSTED);

        if current {

            if self.online.elder != Elder::Beaten {

                self.online.elder = Elder::Beaten;

                self.touch();

            }

            return Ok(Outcome::empty(StatusCode::NOT_MODIFIED)

                .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED));

        }

        let spreadsheet = Outcome::raw(StatusCode::OK, "text/csv; header=present", SPREADSHEET)

            .header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED);

        if self.online.filmed_at.is_some() {

            return Ok(spreadsheet.header(X_FORUM_NOTE, "We have seen the footage."));

        }

        Ok(spreadsheet)

    }

}