jelq

use super::{

    Floor, Lube, Outcome, Run, Story, Technique,

    techniques::{Training, Utility},

};

use crate::problem::Problem;

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

use serde_json::{Value, json};

use std::{fmt::Write as _, ops::ControlFlow};

impl Run {

    pub fn jelq(

        &mut self,

        techniques: &[Technique],

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        if techniques != [Technique::Utility(Utility::Energy)] {

            self.check_exhausted()?;

        }

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

            return Ok(self.branch_offer());

        }

        if self.floor == Floor::Forum {

            return Ok(Outcome::json(

                StatusCode::SEE_OTHER,

                json!({ "detail": "Refer to the forum." }),

            )

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

        }

        self.check_cage()?;

        match *techniques {

            [Technique::Utility(utility)] => self.utility(utility, lube),

            [Technique::Training(training)] => self.single(training, intensity, lube),

            [Technique::Training(a), Technique::Training(b)] => self.combo(a, b, intensity, lube),

            [_, _] => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "Only training techniques can be combined.",

            )),

            _ => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "too-many-techniques",

                "Two techniques at most. The server has limits even if you do not.",

            )),

        }

    }

    pub(super) fn utility(

        &mut self,

        utility: Utility,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        match utility {

            Utility::Warmup => return self.warm_up(),

            Utility::Ice => return self.ice(),

            Utility::Supplement => return self.supplement(),

            Utility::Meditate => return self.meditate(),

            Utility::Energy => return self.energy(),

            Utility::Edge | Utility::Pump => {}

        }

        let lube = lube.filter(|_| utility == Utility::Edge);

        self.ready(Technique::Utility(utility), lube)?;

        self.check_storage()?;

        self.lube_available(lube)?;

        self.check_clock()?;

        self.floor_enemy()?;

        match utility {

            Utility::Edge => self.edge(lube),

            _ => self.pump(),

        }

    }

    pub(super) fn single(

        &mut self,

        training: Training,

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        self.ready(Technique::Training(training), lube)?;

        self.check_storage()?;

        self.lube_available(lube)?;

        self.check_clock()?;

        self.floor_enemy()?;

        self.take_lube(lube)?;

        let cold = self.cold();

        self.chafe(lube, intensity, cold);

        self.commit(intensity, lube, 1)?;

        if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity, cold)? {

            return Ok(interrupted);

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let outcome = self.roll(training, intensity, lube)?;

        Ok(self.gossip(outcome))

    }

    pub(super) fn combo(

        &mut self,

        a: Training,

        b: Training,

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        if a == b {

            return Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "A technique cannot be combined with itself. The server has checked.",

            ));

        }

        self.ready(Technique::Training(a), lube)?;

        self.ready(Technique::Training(b), lube)?;

        self.check_storage()?;

        self.lube_available(lube)?;

        self.check_clock()?;

        self.floor_enemy()?;

        self.take_lube(lube)?;

        let cold = self.cold();

        self.chafe(lube, intensity, cold);

        self.chafe(lube, intensity, cold);

        self.commit(intensity, lube, 2)?;

        for training in [a, b] {

            if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity, cold)? {

                return Ok(interrupted);

            }

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let mut reports = Vec::new();

        for training in [a, b] {

            let result = self.roll(training, intensity, lube);

            if self.ended.is_some() {

                return result;

            }

            reports.push((

                training,

                Report::of(result.map(|outcome| self.gossip(outcome))),

            ));

        }

        let mut xml = String::from(

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\" xmlns:J=\"https://jelq.dev/\">\n",

        );

        for (training, report) in reports {

            report.write(

                &mut xml,

                &format!("{}?technique={}", self.path(""), training.name()),

            );

        }

        xml.push_str(

            "  <D:responsedescription>Each technique has been reported separately.</D:responsedescription>\n</D:multistatus>\n",

        );

        Ok(Outcome::raw(

            StatusCode::MULTI_STATUS,

            "application/xml; charset=utf-8",

            xml,

        ))

    }

}

/// What one technique of a combo would have answered on its own.

struct Report {

    status: StatusCode,

    error: Option<&'static str>,

    detail: Option<String>,

    fields: Vec<(String, String)>,

    location: Option<String>,

}

impl Report {

    fn of(result: Result<Outcome, Problem>) -> Self {

        let (status, error, location, body) = match result {

            Ok(outcome) => (

                outcome.status(),

                None,

                outcome.header_value(&header::LOCATION).map(str::to_owned),

                outcome.body().and_then(Value::as_object).cloned(),

            ),

            Err(problem) => {

                let mut document = problem.document();

                for repeated in ["type", "title", "status"] {

                    document.remove(repeated);

                }

                (problem.status(), Some(problem.slug()), None, Some(document))

            }

        };

        let mut body = body.unwrap_or_default();

        let detail = body

            .remove("detail")

            .and_then(|detail| detail.as_str().map(str::to_owned));

        let fields = body

            .into_iter()

            .map(|(key, value)| match value {

                Value::String(text) => (key, text),

                other => (key, other.to_string()),

            })

            .collect();

        Self {

            status,

            error,

            detail,

            fields,

            location,

        }

    }

    /// In RFC 4918's order, with anything the game adds after it under its own namespace.

    fn write(&self, xml: &mut String, href: &str) {

        let _ = write!(

            xml,

            "  <D:response>\n    <D:href>{}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n",

            escape(href),

            self.status.as_u16(),

            crate::problem::reason(self.status),

        );

        if let Some(error) = self.error {

            let _ = writeln!(xml, "    <D:error><J:{error}/></D:error>");

        }

        if let Some(detail) = &self.detail {

            let _ = writeln!(

                xml,

                "    <D:responsedescription>{}</D:responsedescription>",

                escape(detail)

            );

        }

        if let Some(location) = &self.location {

            let _ = writeln!(

                xml,

                "    <D:location><D:href>{}</D:href></D:location>",

                escape(location)

            );

        }

        for (key, value) in &self.fields {

            let _ = writeln!(xml, "    <J:{key}>{}</J:{key}>", escape(value));

        }

        xml.push_str("  </D:response>\n");

    }

}

fn escape(text: &str) -> String {

    text.replace('&', "&")

        .replace('<', "&lt;")

        .replace('>', ">")

}