essences/

quest.rs

use crate::{bundles::BundleElement, prelude::*, screen_ref::ScreenType};
use strum_macros::{Display, EnumString};

use crate::{bundles::BundleId, currency::CurrencyUnit};

#[declare]
pub type QuestId = Uuid;

#[derive(
    Clone,
    Copy,
    Debug,
    Serialize,
    Deserialize,
    JsonSchema,
    EnumString,
    Display,
    PartialEq,
    Eq,
    Tsify,
    Hash,
)]
pub enum QuestGroupType {
    Daily,
    Weekly,
    Lifetime,
    LoopTask,
    PatronDaily,
    PatronLifetime,
    Hidden,
    Achievement,
}

impl CustomType for QuestGroupType {
    fn build(mut builder: TypeBuilder<Self>) {
        builder
            .with_name("QuestType")
            .with_get("str", |qt: &mut QuestGroupType| {
                QuestGroupType::to_string(qt)
            });
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, JsonSchema, Tsify)]
pub struct QuestTemplate {
    #[schemars(schema_with = "id_schema")]
    pub id: QuestId,

    #[schemars(title = "Название квеста")]
    pub title: i18n::I18nString,
    #[schemars(title = "Описание квеста")]
    pub description: i18n::I18nString,

    #[schemars(
        title = "Скрипт квеста",
        description = "Скрипт высчитывающий текущий прогресс по квесту",
        schema_with = "script_schema"
    )]
    pub progress_script: String,

    #[schemars(title = "Конечная цель по квесту")]
    pub progress_target: i64,

    #[schemars(title = "Тип группы квестов")]
    pub quest_group_type: QuestGroupType,

    #[schemars(
        title = "Бандл награды за квест",
        description = "ID бандла с наградами за выполнение квеста",
        schema_with = "option_bundle_id_schema"
    )]
    pub bundle_id: Option<BundleId>,

    #[schemars(title = "Очки прогресса для группы за выполнения квеста")]
    pub progression_points: u64,

    #[schemars(title = "Выдается ли квест на создании персонажа")]
    pub starting: bool,

    #[schemars(
        title = "Квесты, которые выдаются по завершению данного квеста",
        schema_with = "quest_link_id_array_schema"
    )]
    pub next_quest_ids: Vec<QuestId>,

    #[schemars(title = "Подписка на эвенты")]
    pub events_subscribe: Vec<String>,

    #[schemars(
        title = "Скрипт дополнительных квестов",
        description = "Опциональный скрипт, который может выдать дополнительные квесты",
        schema_with = "option_script_schema"
    )]
    pub additional_quests_script: Option<String>,

    #[schemars(title = "Засчитывается ли прогресс по повторяющемуся квесту, если он не активен")]
    pub progress_if_inactive: bool,

    #[schemars(title = "На какой экран ссылается квест")]
    pub screen_reference: Option<ScreenType>,

    #[schemars(title = "Код квеста для цепочки loop task")]
    pub code: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, CustomType, Tsify)]
pub struct QuestInstance {
    pub id: QuestId,
    pub current: i64,
    pub reward: Vec<BundleElement>,
    pub is_claimed: bool,
}

impl QuestInstance {
    pub fn is_completed(&self, target: i64) -> bool {
        self.current >= target
    }
}

impl CustomType for QuestTemplate {
    fn build(mut builder: TypeBuilder<Self>) {
        builder
            .with_name("Quest")
            .with_get("id", |quest: &mut Self| quest.id)
            .with_get("title", |quest: &mut Self| quest.title.clone())
            .with_get("progress_script", |quest: &mut Self| {
                quest.progress_script.clone()
            })
            .with_get("quest_group_type", |quest: &mut Self| {
                QuestGroupType::to_string(&quest.quest_group_type)
            })
            .with_get("bundle_id", |quest: &mut Self| quest.bundle_id);
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
pub struct QuestsProgressionPointSettings {
    #[schemars(title = "Очки прогресса по квесту")]
    pub points: u64,

    #[schemars(
        title = "Скрипт награды за очки прогресса",
        schema_with = "script_schema"
    )]
    pub reward_script: String,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema, Tsify)]
pub struct QuestsProgressionSettings {
    #[schemars(title = "Настройки ежедневного квеста")]
    pub daily: Vec<QuestsProgressionPointSettings>,

    #[schemars(title = "Настройки еженедельного квеста")]
    pub weekly: Vec<QuestsProgressionPointSettings>,

    #[schemars(title = "Настройки ачивок")]
    pub achievement: Vec<QuestsProgressionPointSettings>,
}

#[derive(
    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, CustomType, Tsify,
)]
pub struct QuestsProgressTrack {
    pub current_points: u64,
    pub period_end_date: chrono::DateTime<chrono::Utc>,
    pub rewards: Vec<QuestsTrackReward>,
}

#[derive(
    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, CustomType, Tsify,
)]
pub struct QuestsTrackReward {
    pub points_required: u64,
    pub reward: Vec<CurrencyUnit>,
    pub is_claimed: bool,
}

#[derive(
    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, CustomType, Tsify,
)]
pub struct QuestsProgressionGroup {
    pub progress_track: QuestsProgressTrack,
    pub quests: Vec<QuestInstance>,
}

#[derive(
    Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq, JsonSchema, CustomType, Tsify,
)]
pub struct QuestsGroups {
    pub daily: QuestsProgressionGroup,
    pub weekly: QuestsProgressionGroup,
    pub lifetime: Vec<QuestInstance>,
    pub loop_tasks: Vec<QuestInstance>,
    pub patron_daily: Vec<QuestInstance>,
    pub patron_lifetime: Vec<QuestInstance>,
    pub hidden: Vec<QuestInstance>,
    pub achievements: QuestsProgressionGroup,
}

impl QuestsGroups {
    pub fn iter(&self) -> impl Iterator<Item = &QuestInstance> {
        self.lifetime
            .iter()
            .chain(self.loop_tasks.iter())
            .chain(self.patron_daily.iter())
            .chain(self.patron_lifetime.iter())
            .chain(self.daily.quests.iter())
            .chain(self.weekly.quests.iter())
            .chain(self.hidden.iter())
            .chain(self.achievements.quests.iter())
    }

    pub fn iter_repeatable(&self) -> impl Iterator<Item = &QuestInstance> {
        self.daily.quests.iter().chain(self.weekly.quests.iter())
    }

    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut QuestInstance> {
        self.daily
            .quests
            .iter_mut()
            .chain(self.weekly.quests.iter_mut())
            .chain(self.lifetime.iter_mut())
            .chain(self.loop_tasks.iter_mut())
            .chain(self.patron_daily.iter_mut())
            .chain(self.patron_lifetime.iter_mut())
            .chain(self.hidden.iter_mut())
            .chain(self.achievements.quests.iter_mut())
    }

    pub fn mark_quest_claimed(&mut self, quest_id: QuestId) -> anyhow::Result<()> {
        if let Some(quest) = self
            .daily
            .quests
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .weekly
            .quests
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .lifetime
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .loop_tasks
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .patron_daily
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .patron_lifetime
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        if let Some(quest) = self
            .achievements
            .quests
            .iter_mut()
            .find(|q| q.id == quest_id && !q.is_claimed)
        {
            quest.is_claimed = true;
            return Ok(());
        }

        anyhow::bail!("Didn't find unclaimed quest with id: {quest_id}")
    }

    pub fn get_not_claimed_quests(&self) -> Vec<&QuestInstance> {
        let mut quests = vec![];

        quests.extend(self.daily.quests.iter().filter(|q| !q.is_claimed));

        quests.extend(self.weekly.quests.iter().filter(|q| !q.is_claimed));

        quests.extend(self.lifetime.iter().filter(|q| !q.is_claimed));

        quests.extend(self.loop_tasks.iter().filter(|q| !q.is_claimed));

        quests.extend(self.patron_daily.iter().filter(|q| !q.is_claimed));

        quests.extend(self.patron_lifetime.iter().filter(|q| !q.is_claimed));

        quests.extend(self.hidden.iter().filter(|q| !q.is_claimed));

        quests.extend(self.achievements.quests.iter().filter(|q| !q.is_claimed));

        quests
    }

    pub fn get_not_claimed_quests_mut(&mut self) -> Vec<&mut QuestInstance> {
        let mut quests = vec![];

        quests.extend(self.daily.quests.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.weekly.quests.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.lifetime.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.loop_tasks.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.patron_daily.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.patron_lifetime.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(self.hidden.iter_mut().filter(|q| !q.is_claimed));

        quests.extend(
            self.achievements
                .quests
                .iter_mut()
                .filter(|q| !q.is_claimed),
        );

        quests
    }

    pub fn len(&self) -> usize {
        self.daily.quests.len()
            + self.weekly.quests.len()
            + self.lifetime.len()
            + self.loop_tasks.len()
            + self.patron_daily.len()
            + self.patron_lifetime.len()
            + self.hidden.len()
            + self.achievements.quests.len()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    pub fn push(&mut self, quest: &QuestInstance, group_type: &QuestGroupType) {
        match group_type {
            QuestGroupType::Daily => self.daily.quests.push(quest.clone()),
            QuestGroupType::Weekly => self.weekly.quests.push(quest.clone()),
            QuestGroupType::Lifetime => self.lifetime.push(quest.clone()),
            QuestGroupType::LoopTask => self.loop_tasks.push(quest.clone()),
            QuestGroupType::PatronDaily => self.patron_daily.push(quest.clone()),
            QuestGroupType::PatronLifetime => self.patron_lifetime.push(quest.clone()),
            QuestGroupType::Hidden => self.hidden.push(quest.clone()),
            QuestGroupType::Achievement => self.achievements.quests.push(quest.clone()),
        }
    }

    pub fn retain_all(&mut self, quest_id: QuestId) {
        self.daily.quests.retain(|x| x.id != quest_id);
        self.weekly.quests.retain(|x| x.id != quest_id);
        self.lifetime.retain(|x| x.id != quest_id);
        self.loop_tasks.retain(|x| x.id != quest_id);
        self.patron_daily.retain(|x| x.id != quest_id);
        self.patron_lifetime.retain(|x| x.id != quest_id);
        self.hidden.retain(|x| x.id != quest_id);
        self.achievements.quests.retain(|x| x.id != quest_id);
    }

    pub fn find_in_all(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.daily
            .quests
            .iter()
            .find(|x| x.id == quest_id)
            .or_else(|| self.weekly.quests.iter().find(|x| x.id == quest_id))
            .or_else(|| self.lifetime.iter().find(|x| x.id == quest_id))
            .or_else(|| self.loop_tasks.iter().find(|x| x.id == quest_id))
            .or_else(|| self.patron_daily.iter().find(|x| x.id == quest_id))
            .or_else(|| self.patron_lifetime.iter().find(|x| x.id == quest_id))
            .or_else(|| self.hidden.iter().find(|x| x.id == quest_id))
            .or_else(|| self.achievements.quests.iter().find(|x| x.id == quest_id))
            .cloned()
    }

    pub fn retain_patron(&mut self, quest_id: QuestId) {
        self.patron_daily.retain(|x| x.id != quest_id);
        self.patron_lifetime.retain(|x| x.id != quest_id);
    }

    pub fn find_in_patron(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.patron_daily
            .iter()
            .find(|x| x.id == quest_id)
            .or_else(|| self.patron_lifetime.iter().find(|x| x.id == quest_id))
            .cloned()
    }

    pub fn retain_repeatable(&mut self, quest_id: QuestId) {
        self.daily.quests.retain(|x| x.id != quest_id);
        self.weekly.quests.retain(|x| x.id != quest_id);
    }

    pub fn find_in_repeatable(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.daily
            .quests
            .iter()
            .find(|x| x.id == quest_id)
            .or_else(|| self.weekly.quests.iter().find(|x| x.id == quest_id))
            .cloned()
    }

    pub fn find_in_repeatable_mut(&mut self, quest_id: QuestId) -> Option<&mut QuestInstance> {
        self.daily
            .quests
            .iter_mut()
            .find(|x| x.id == quest_id)
            .or_else(|| self.weekly.quests.iter_mut().find(|x| x.id == quest_id))
    }

    /// Remove a claimed loop task so it can be re-created fresh
    /// via NewQuests at the end of the list.
    pub fn reset_loop_task(&mut self, quest_id: QuestId) {
        self.loop_tasks.retain(|x| x.id != quest_id);
    }

    pub fn find_in_loop_tasks(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.loop_tasks.iter().find(|x| x.id == quest_id).cloned()
    }

    pub fn retain_lifetime(&mut self, quest_id: QuestId) {
        self.lifetime.retain(|x| x.id != quest_id);
    }

    pub fn find_in_lifetime(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.lifetime.iter().find(|x| x.id == quest_id).cloned()
    }

    pub fn retain_hidden(&mut self, quest_id: QuestId) {
        self.hidden.retain(|x| x.id != quest_id);
    }

    pub fn find_in_hidden(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.hidden.iter().find(|x| x.id == quest_id).cloned()
    }

    pub fn find_in_non_patron(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.find_in_lifetime(quest_id)
            .or_else(|| self.find_in_loop_tasks(quest_id))
            .or_else(|| self.find_in_repeatable(quest_id))
            .or_else(|| self.find_in_achievements(quest_id))
    }

    pub fn retain_achievements(&mut self, quest_id: QuestId) {
        self.achievements.quests.retain(|x| x.id != quest_id);
    }

    pub fn find_in_achievements(&self, quest_id: QuestId) -> Option<QuestInstance> {
        self.achievements
            .quests
            .iter()
            .find(|x| x.id == quest_id)
            .cloned()
    }
}