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:\">\n",

        );

        for (training, report) in reports {

            let _ = write!(

                xml,

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

                self.path(""),

                training.name(),

                report.status.as_u16(),

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

            );

            if let Some(location) = report.location {

                let _ = writeln!(

                    xml,

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

                    escape(&location)

                );

            }

            if let Some(text) = report.text {

                let _ = writeln!(

                    xml,

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

                    escape(&text)

                );

            }

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

        }

        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,

    location: Option<String>,

    text: Option<String>,

}

impl Report {

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

        match result {

            Ok(outcome) => Self {

                status: outcome.status(),

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

                text: outcome.body().map(Value::to_string),

            },

            Err(problem) => Self {

                status: problem.status(),

                location: None,

                text: Some(Value::Object(problem.document()).to_string()),

            },

        }

    }

}

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

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

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

        .replace('>', ">")

}