jelq

use std::time::SystemTime;

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

use serde_json::{Value, json};

use super::{

    Cause, Elder, Floor, Outcome, Run, Story,

    balance::{EXAGGERATION, PATIENCE, ULI_ODDS, ULI_READS},

    body::exaggeration,

    honest, parse_credentials,

};

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";

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 nothing_new() -> Outcome {

    Outcome::empty(StatusCode::NOT_MODIFIED).header(

        header::WARNING,

        r#"199 - "Nothing new has been posted since 2009.""#,

    )

}

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": "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\"")

}

impl Run {

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

        let forum = self.path("/branches/forum");

        let close = self.path("/branches/close-tab");

        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: &str) -> Result<Outcome, Problem> {

        if self.story != Story::Pending {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "no-decision-pending",

                "There is no decision pending.",

            ));

        }

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

            "forum" => {

                self.shame += 3;

                let detail =

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

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

            }

            "close-tab" => {

                self.suspicion = 0;

                (

                    Story::ClosedTab,

                    self.path(""),

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

                )

            }

            _ => {

                return Err(Problem::new(

                    StatusCode::NOT_FOUND,

                    "no-such-choice",

                    "That was not one of the choices.",

                ));

            }

        };

        self.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.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        if !self.thread_reachable() {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "no-thread",

                "There is no thread to re-read. Nobody has mentioned a forum yet.",

            ));

        }

        self.end_kitchen_visit();

        if self.uli_taught {

            return Ok(Outcome::json(StatusCode::OK, forum_thread()));

        }

        if self.here.thread_rolls >= ULI_READS {

            let age = httpdate::parse_http_date(ELDER_LAST_MODIFIED)

                .ok()

                .and_then(|posted| SystemTime::now().duration_since(posted).ok())

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

            return Ok(Outcome::json(StatusCode::OK, forum_thread())

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

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

        }

        self.here.thread_rolls += 1;

        self.touch();

        if self.chance(

            self.decision(

                "teach-uli",

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

            ),

            ULI_ODDS,

        ) {

            self.uli_taught = true;

            return Ok(Outcome::json(

                StatusCode::OK,

                json!({ "detail": "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." }),

            )

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

        }

        Ok(nothing_new())

    }

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

        self.touch();

        let Elder::Unverified { strikes } = &mut self.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.elder, Elder::Unverified { .. }) {

            return Ok(());

        }

        let Some(credentials) = proxy_authorization else {

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

        };

        let Some(claimed) =

            parse_credentials(credentials, "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.shame += 2;

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

        }

        if !honest(claimed, actual) {

            self.shame += 1;

            return Err(self.elder_strike(verification("Verification failed. The forum can tell.")));

        }

        self.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 last_modified =

            httpdate::parse_http_date(ELDER_LAST_MODIFIED).expect("valid constant date");

        let current = if_modified_since

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

            .is_some_and(|since| since >= last_modified);

        if current {

            if self.elder != Elder::Beaten {

                self.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.filmed_at.is_some() {

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

        }

        Ok(spreadsheet)

    }

}