use super::{combat::change_health, comms::broadcast_to_room};
#[double]
use crate::db::DBTrans;
use crate::{
    models::{
        effect::{Effect, EffectSet, EffectType},
        item::Item,
        task::{Task, TaskDetails, TaskMeta},
    },
    regular_tasks::{TaskHandler, TaskRunContext},
    DResult,
};
use async_trait::async_trait;
use chrono::Utc;
use log::info;
use mockall_double::double;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, VecDeque};
use std::time;

#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub struct DelayedHealthEffect {
    magnitude: i64,
    delay: u64,
    message: String,
    message_nonexp: String,
}

#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub struct DelayedMessageEffect {
    delay: u64,
    message: String,
    message_nonexp: String,
}

pub struct DelayedHealthTaskHandler;
#[async_trait]
impl TaskHandler for DelayedHealthTaskHandler {
    async fn do_task(&self, ctx: &mut TaskRunContext) -> DResult<Option<time::Duration>> {
        let ref mut item_effect_series = match &mut ctx.task.details {
            TaskDetails::DelayedHealth {
                item,
                ref mut effect_series,
            } => (item, effect_series),
            _ => Err("Expected DelayedHealth type")?,
        };
        let (item_type, item_code) = match item_effect_series.0.split_once("/") {
            None => {
                info!(
                    "Invalid item {} to DelayedHealthTaskHandler",
                    item_effect_series.0
                );
                return Ok(None);
            }
            Some((item_type, item_code)) => (item_type, item_code),
        };
        let item = match ctx
            .trans
            .find_item_by_type_code(item_type, item_code)
            .await?
        {
            None => {
                return Ok(None);
            }
            Some(it) => it,
        };
        if item.death_data.is_some() {
            return Ok(None);
        }
        match item_effect_series.1.pop_front() {
            None => Ok(None),
            Some(DelayedHealthEffect {
                magnitude,
                message,
                message_nonexp,
                ..
            }) => {
                let mut item_mut = (*item).clone();
                change_health(
                    ctx.trans,
                    magnitude,
                    &mut item_mut,
                    &message,
                    &message_nonexp,
                )
                .await?;
                ctx.trans.save_item_model(&item_mut).await?;
                Ok(item_effect_series
                    .1
                    .front()
                    .map(|it| time::Duration::from_secs(it.delay)))
            }
        }
    }
}
pub static DELAYED_HEALTH_HANDLER: &'static (dyn TaskHandler + Sync + Send) =
    &DelayedHealthTaskHandler;

pub struct DelayedMessageTaskHandler;
#[async_trait]
impl TaskHandler for DelayedMessageTaskHandler {
    async fn do_task(&self, ctx: &mut TaskRunContext) -> DResult<Option<time::Duration>> {
        let ref mut item_effect_series = match &mut ctx.task.details {
            TaskDetails::DelayedMessage {
                item,
                ref mut effect_series,
            } => (item, effect_series),
            _ => Err("Expected DelayedMessage type")?,
        };
        let (item_type, item_code) = match item_effect_series.0.split_once("/") {
            None => {
                info!(
                    "Invalid item {} to DelayedMessageTaskHandler",
                    item_effect_series.0
                );
                return Ok(None);
            }
            Some((item_type, item_code)) => (item_type, item_code),
        };
        let item = match ctx
            .trans
            .find_item_by_type_code(item_type, item_code)
            .await?
        {
            None => {
                return Ok(None);
            }
            Some(it) => it,
        };
        if item.death_data.is_some() {
            return Ok(None);
        }
        match item_effect_series.1.pop_front() {
            None => Ok(None),
            Some(DelayedMessageEffect {
                message,
                message_nonexp,
                ..
            }) => {
                broadcast_to_room(
                    &ctx.trans,
                    &item.location,
                    None,
                    &message,
                    Some(&message_nonexp),
                )
                .await?;
                Ok(item_effect_series
                    .1
                    .front()
                    .map(|it| time::Duration::from_secs(it.delay)))
            }
        }
    }
}
pub static DELAYED_MESSAGE_HANDLER: &'static (dyn TaskHandler + Sync + Send) =
    &DelayedMessageTaskHandler;

pub struct DispelEffectTaskHandler;
#[async_trait]
impl TaskHandler for DispelEffectTaskHandler {
    async fn do_task(&self, ctx: &mut TaskRunContext) -> DResult<Option<time::Duration>> {
        let (target_str, effect_type) = match ctx.task.details {
            TaskDetails::DispelEffect {
                target: ref t,
                effect_type: ref e,
            } => (t.as_str(), e),
            _ => Err("Expected DispelEffect type")?,
        };
        let (target_type, target_code) = match target_str.split_once("/") {
            None => Err("Invalid DispelEffect target")?,
            Some(v) => v,
        };
        let target = match ctx
            .trans
            .find_item_by_type_code(target_type, target_code)
            .await?
        {
            None => return Ok(None),
            Some(t) => t,
        };
        let mut target_mut = (*target).clone();
        target_mut
            .active_effects
            .iter()
            .position(|e| e == effect_type)
            .map(|p| target_mut.active_effects.remove(p));
        ctx.trans.save_item_model(&target_mut).await?;
        Ok(None)
    }
}
pub static DISPEL_EFFECT_HANDLER: &'static (dyn TaskHandler + Sync + Send) =
    &DispelEffectTaskHandler;

pub async fn run_effects(
    trans: &DBTrans,
    effects: &EffectSet,
    player: &mut Item,
    item: &Item,
    // None if target is player
    target: &mut Option<Item>,
    level: f64,
    task_ref: &str,
) -> DResult<()> {
    let mut target_health_series = BTreeMap::<String, VecDeque<DelayedHealthEffect>>::new();
    let mut target_message_series = BTreeMap::<String, VecDeque<DelayedMessageEffect>>::new();
    let mut dispel_time_secs: u64 = 0;
    for effect in &effects.effects {
        match effect {
            Effect::BroadcastMessage {
                delay_secs,
                messagef,
            } => {
                let (msg_exp, msg_nonexp) =
                    messagef(player, item, target.as_ref().unwrap_or(player));
                if *delay_secs == 0 {
                    broadcast_to_room(trans, &player.location, None, &msg_exp, Some(&msg_nonexp))
                        .await?;
                } else {
                    dispel_time_secs = dispel_time_secs.max(*delay_secs);
                    let target_it = target.as_ref().unwrap_or(player);
                    let fx = DelayedMessageEffect {
                        delay: *delay_secs,
                        message: msg_exp,
                        message_nonexp: msg_nonexp,
                    };
                    target_message_series
                        .entry(format!("{}/{}", target_it.item_type, target_it.item_code))
                        .and_modify(|l| l.push_back(fx.clone()))
                        .or_insert(VecDeque::from([fx]));
                }
            }
            Effect::ChangeTargetHealth {
                delay_secs,
                base_effect,
                skill_multiplier,
                max_effect,
                message,
            } => {
                let health_impact =
                    (*base_effect + ((skill_multiplier * level) as i64).min(*max_effect)) as i64;
                let (msg, msg_nonexp) = message(target.as_ref().unwrap_or(player));
                if *delay_secs == 0 {
                    change_health(
                        trans,
                        health_impact,
                        target.as_mut().unwrap_or(player),
                        &msg,
                        &msg_nonexp,
                    )
                    .await?;
                } else {
                    dispel_time_secs = dispel_time_secs.max(*delay_secs);
                    let target_it = target.as_ref().unwrap_or(player);
                    let fx = DelayedHealthEffect {
                        magnitude: health_impact,
                        delay: *delay_secs,
                        message: msg,
                        message_nonexp: msg_nonexp,
                    };
                    target_health_series
                        .entry(format!("{}/{}", target_it.item_type, target_it.item_code))
                        .and_modify(|l| l.push_back(fx.clone()))
                        .or_insert(VecDeque::from([fx]));
                }
            }
        }
    }

    if dispel_time_secs > 0 && effects.effect_type != EffectType::Ephemeral {
        let target_item = target.as_mut().unwrap_or(player);
        target_item.active_effects.push(effects.effect_type.clone());

        trans
            .upsert_task(&Task {
                meta: TaskMeta {
                    task_code: format!("{}/{}", &target_item.refstr(), task_ref),
                    next_scheduled: Utc::now() + chrono::Duration::seconds(dispel_time_secs as i64),
                    ..Default::default()
                },
                details: TaskDetails::DispelEffect {
                    target: target_item.refstr(),
                    effect_type: effects.effect_type.clone(),
                },
            })
            .await?;
    }

    for (eff_item, l) in target_health_series.into_iter() {
        trans
            .upsert_task(&Task {
                meta: TaskMeta {
                    task_code: format!("{}/{}", eff_item, task_ref),
                    next_scheduled: Utc::now() + chrono::Duration::seconds(l[0].delay as i64),
                    ..Default::default()
                },
                details: TaskDetails::DelayedHealth {
                    effect_series: l,
                    item: eff_item,
                },
            })
            .await?;
    }
    for (eff_item, l) in target_message_series.into_iter() {
        trans
            .upsert_task(&Task {
                meta: TaskMeta {
                    task_code: format!("{}/{}", eff_item, task_ref),
                    next_scheduled: Utc::now() + chrono::Duration::seconds(l[0].delay as i64),
                    ..Default::default()
                },
                details: TaskDetails::DelayedMessage {
                    effect_series: l,
                    item: eff_item,
                },
            })
            .await?;
    }

    Ok(())
}