jelq

use super::{

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

    techniques::{Training, Utility},

};

use crate::problem::Problem;

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

use serde_json::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")));

        }

        if self.items.kit.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",

                "The cage is locked. The key is not in the box.",

            ));

        }

        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 => {}

        }

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

        self.check_storage()?;

        self.floor_enemy()?;

        match utility {

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

            _ => 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.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.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 statuses = Vec::new();

        for training in [a, b] {

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

            if self.ended.is_some() {

                return result;

            }

            let status = match result {

                Ok(outcome) => self.gossip(outcome).status(),

                Err(problem) => problem.status(),

            };

            statuses.push((training, status));

        }

        let mut xml = String::from(

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",

        );

        for (training, status) in statuses {

            let _ = write!(

                xml,

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

                self.path(""),

                training.name(),

                status.as_u16(),

                crate::problem::reason(status),

            );

        }

        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,

        ))

    }

}