pub mod changes;
mod process;

use core::num::NonZeroU8;
use std::collections::VecDeque;

use serde::{Deserialize, Serialize};
use werewolves_macros::Extract;

use super::Result;
use crate::{
    character::{Character, CharacterId},
    diedto::DiedTo,
    error::GameError,
    game::{
        GameTime, Village,
        kill::{self},
        night::changes::{ChangesLookup, NightChange},
        story::NightChoice,
    },
    message::night::{ActionPrompt, ActionResponse, ActionResult, Visits},
    player::Protection,
    role::{PYREMASTER_VILLAGER_KILLS_TO_DIE, RoleBlock, RoleTitle},
};

enum BlockResolvedOutcome {
    PromptUpdate(ActionPrompt),
    ActionComplete(ActionResult, Option<NightChange>),
}

enum ResponseOutcome {
    PromptUpdate(ActionPrompt),
    ActionComplete(ActionComplete),
}

struct ActionComplete {
    pub result: ActionResult,
    pub change: Option<NightChange>,
}

impl From<ActionComplete> for ResponseOutcome {
    fn from(value: ActionComplete) -> Self {
        ResponseOutcome::ActionComplete(value)
    }
}

impl ActionPrompt {
    fn unless(&self) -> Option<Unless> {
        match &self {
            ActionPrompt::Insomniac { .. }
            | ActionPrompt::MasonsWake { .. }
            | ActionPrompt::WolvesIntro { .. }
            | ActionPrompt::RoleChange { .. }
            | ActionPrompt::Shapeshifter { .. }
            | ActionPrompt::ElderReveal { .. }
            | ActionPrompt::CoverOfDarkness => None,

            ActionPrompt::Arcanist {
                marked: (Some(marked1), Some(marked2)),
                ..
            } => Some(Unless::TargetsBlocked(*marked1, *marked2)),

            ActionPrompt::LoneWolfKill {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Seer {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Protector {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Gravedigger {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Hunter {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Militia {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::MapleWolf {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Guardian {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Adjudicator {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::PowerSeer {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Mortician {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Beholder {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::MasonLeaderRecruit {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Empath {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::Vindicator {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::PyreMaster {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::WolfPackKill {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::AlphaWolf {
                marked: Some(marked),
                ..
            }
            | ActionPrompt::DireWolf {
                marked: Some(marked),
                ..
            } => Some(Unless::TargetBlocked(*marked)),

            ActionPrompt::LoneWolfKill { marked: None, .. }
            | ActionPrompt::Seer { marked: None, .. }
            | ActionPrompt::Protector { marked: None, .. }
            | ActionPrompt::Gravedigger { marked: None, .. }
            | ActionPrompt::Hunter { marked: None, .. }
            | ActionPrompt::Militia { marked: None, .. }
            | ActionPrompt::MapleWolf { marked: None, .. }
            | ActionPrompt::Guardian { marked: None, .. }
            | ActionPrompt::Adjudicator { marked: None, .. }
            | ActionPrompt::PowerSeer { marked: None, .. }
            | ActionPrompt::Mortician { marked: None, .. }
            | ActionPrompt::Beholder { marked: None, .. }
            | ActionPrompt::MasonLeaderRecruit { marked: None, .. }
            | ActionPrompt::Empath { marked: None, .. }
            | ActionPrompt::Vindicator { marked: None, .. }
            | ActionPrompt::PyreMaster { marked: None, .. }
            | ActionPrompt::WolfPackKill { marked: None, .. }
            | ActionPrompt::AlphaWolf { marked: None, .. }
            | ActionPrompt::DireWolf { marked: None, .. }
            | ActionPrompt::Arcanist {
                marked: (Some(_), None),
                ..
            }
            | ActionPrompt::Arcanist {
                marked: (None, Some(_)),
                ..
            }
            | ActionPrompt::Arcanist {
                marked: (None, None),
                ..
            } => None,
        }
    }
}

impl Default for ActionComplete {
    fn default() -> Self {
        Self {
            result: ActionResult::GoBackToSleep,
            change: None,
        }
    }
}

enum Unless {
    TargetBlocked(CharacterId),
    TargetsBlocked(CharacterId, CharacterId),
}

impl From<Unless> for ActionResult {
    fn from(value: Unless) -> Self {
        match value {
            Unless::TargetBlocked(_) | Unless::TargetsBlocked(_, _) => ActionResult::RoleBlocked,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[allow(clippy::large_enum_variant)]
enum NightState {
    Active {
        current_prompt: ActionPrompt,
        current_result: Option<ActionResult>,
        current_changes: Vec<NightChange>,
        current_page: usize,
    },
    Complete,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Night {
    village: Village,
    night: u8,
    action_queue: VecDeque<ActionPrompt>,
    used_actions: Vec<(ActionPrompt, ActionResult, Vec<NightChange>)>,
    night_state: NightState,
}

impl Night {
    pub fn new(village: Village) -> Result<Self> {
        let night = match village.time() {
            GameTime::Day { number: _ } => return Err(GameError::NotNight),
            GameTime::Night { number } => number,
        };

        let filter = if village.executed_known_elder() {
            // there is a lynched elder, remove villager PRs from the prompts
            filter::no_village
        } else {
            filter::no_filter
        };

        let mut action_queue = village
            .characters()
            .into_iter()
            .filter(filter)
            .map(|c| c.night_action_prompts(&village))
            .collect::<Result<Box<[_]>>>()?
            .into_iter()
            .flatten()
            .chain(village.wolf_pack_kill())
            .collect::<Vec<_>>();
        action_queue.sort_by(|left_prompt, right_prompt| {
            left_prompt
                .partial_cmp(right_prompt)
                .unwrap_or(core::cmp::Ordering::Equal)
        });
        let mut action_queue = VecDeque::from(action_queue);

        if night == 0 {
            action_queue.push_front(ActionPrompt::WolvesIntro {
                wolves: village
                    .living_wolf_pack_players()
                    .into_iter()
                    .map(|w| (w.identity(), w.role_title()))
                    .collect(),
            });
        }
        if let Some(prompt) = village.wolf_revert_prompt() {
            match &prompt {
                ActionPrompt::RoleChange {
                    character_id,
                    new_role,
                } => {
                    action_queue = Self::remove_reverted_prompts(
                        action_queue,
                        character_id.character_id,
                        *new_role,
                    )
                }
                prompt => {
                    log::error!(
                        "wolf_revert_prompt should have returned a role change, got {prompt:?}"
                    )
                }
            }

            action_queue.push_front(prompt);
        }
        let night_state = NightState::Active {
            current_prompt: ActionPrompt::CoverOfDarkness,
            current_changes: Vec::new(),
            current_result: None,
            current_page: 0,
        };

        Ok(Self {
            night,
            village,
            night_state,
            action_queue,
            used_actions: Vec::new(),
        })
    }

    fn remove_reverted_prompts(
        mut action_queue: VecDeque<ActionPrompt>,
        reverting: CharacterId,
        reverting_into: RoleTitle,
    ) -> VecDeque<ActionPrompt> {
        let mut new_queue = VecDeque::new();
        if let Some(wolves) = action_queue.iter_mut().find_map(|q| match q {
            ActionPrompt::WolvesIntro { wolves } => Some(wolves),
            _ => None,
        }) && let Some(w) = wolves.iter_mut().find(|w| w.0.character_id == reverting)
        {
            w.1 = reverting_into;
        }

        // remove prompts by the reverting wolf that are in the queue
        // for prompt in action_queue {
        while let Some(prompt) = action_queue.pop_front() {
            log::warn!("prompt: {:?}", prompt.title());
            let (wolf_id, prompt) = match prompt {
                ActionPrompt::WolvesIntro { mut wolves } => {
                    if let Some(w) = wolves.iter_mut().find(|w| w.0.character_id == reverting) {
                        w.1 = reverting_into;
                    }
                    new_queue.push_back(ActionPrompt::WolvesIntro { wolves });
                    continue;
                }

                ActionPrompt::Shapeshifter { character_id } => (
                    character_id.character_id,
                    ActionPrompt::Shapeshifter { character_id },
                ),
                ActionPrompt::AlphaWolf {
                    character_id,
                    living_villagers,
                    marked,
                } => (
                    character_id.character_id,
                    ActionPrompt::AlphaWolf {
                        character_id,
                        living_villagers,
                        marked,
                    },
                ),
                ActionPrompt::DireWolf {
                    character_id,
                    living_players,
                    marked,
                } => (
                    character_id.character_id,
                    ActionPrompt::DireWolf {
                        character_id,
                        living_players,
                        marked,
                    },
                ),
                ActionPrompt::LoneWolfKill {
                    character_id,
                    living_players,
                    marked,
                } => (
                    character_id.character_id,
                    ActionPrompt::LoneWolfKill {
                        character_id,
                        living_players,
                        marked,
                    },
                ),
                other => {
                    new_queue.push_back(other);
                    continue;
                }
            };
            if wolf_id != reverting {
                new_queue.push_back(prompt);
            }
        }

        new_queue
    }

    /// changes that require no input (such as hunter firing)
    fn automatic_changes(&self) -> Vec<NightChange> {
        let mut changes = Vec::new();
        let night = match NonZeroU8::new(self.night) {
            Some(night) => night,
            None => return changes,
        };
        if !self.village.executed_known_elder() {
            self.village
                .dead_characters()
                .into_iter()
                .filter_map(|c| c.died_to().map(|d| (c, d)))
                .filter_map(|(c, d)| c.hunter().ok().and_then(|h| *h).map(|t| (c, t, d)))
                .filter_map(|(c, t, d)| match d.date_time() {
                    GameTime::Day { number } => (number.get() == night.get()).then_some((c, t)),
                    GameTime::Night { number: _ } => None,
                })
                .map(|(c, target)| NightChange::Kill {
                    target,
                    died_to: DiedTo::Hunter {
                        night,
                        killer: c.character_id(),
                    },
                })
                .for_each(|c| changes.push(c));
        }

        changes
    }

    pub fn previous_state(&mut self) -> Result<()> {
        let (current_prompt, current_result, current_changes) = match &mut self.night_state {
            NightState::Active {
                current_prompt,
                current_result,
                current_changes,
                current_page,
            } => {
                if let Some(page_back) = current_page.checked_sub(1) {
                    *current_page = page_back;
                    return Ok(());
                } else {
                    (current_prompt, current_result, current_changes)
                }
            }
            NightState::Complete => return Err(GameError::NightOver),
        };
        if let Some((mut prompt, _, changes)) = self.used_actions.pop() {
            // Remove the shapeshifter role change from the queue
            if let ActionPrompt::Shapeshifter {
                character_id: ss_char,
            } = &prompt
                && let Some(change) = changes.first()
                && let NightChange::Shapeshift { source, into } = change
                && ss_char.character_id == *source
                && let Some(next) = self.action_queue.pop_front()
                && let ActionPrompt::RoleChange {
                    character_id: role_change_char,
                    ..
                } = &next
                && role_change_char.character_id != *into
            {
                // put it back in
                self.action_queue.push_front(next);
            }

            let ss_target = changes.iter().find_map(|c| match c {
                NightChange::Shapeshift { into, .. } => Some(into),
                _ => None,
            });

            core::mem::swap(&mut prompt, current_prompt);
            let last_prompt = prompt;
            let next_prompt_ss_related_role_change = match (&last_prompt, ss_target) {
                (
                    ActionPrompt::RoleChange {
                        character_id,
                        new_role: RoleTitle::Werewolf,
                    },
                    Some(ss_target),
                ) => character_id.character_id == *ss_target,
                (_, _) => false,
            };
            if !next_prompt_ss_related_role_change {
                // only push the last prompt back in if it's not the
                // role change associated with the shapeshift
                self.action_queue.push_front(last_prompt);
            }
            log::warn!(
                "next prompts: {:?}",
                self.action_queue
                    .iter()
                    .map(ActionPrompt::title)
                    .collect::<Box<[_]>>()
            );
            *current_result = None;
            *current_changes = Vec::new();
            Ok(())
        } else {
            Err(GameError::NoPreviousState)
        }
    }

    #[cfg(test)]
    pub fn action_queue(&self) -> Box<[ActionPrompt]> {
        self.action_queue.iter().cloned().collect()
    }

    pub fn collect_changes(&self) -> Result<Box<[NightChange]>> {
        if !matches!(self.night_state, NightState::Complete) {
            return Err(GameError::NotEndOfNight);
        }
        let mut all_changes = self.automatic_changes();
        all_changes.append(&mut self.changes_from_actions().into_vec());
        Ok(all_changes.into_boxed_slice())
    }

    fn apply_mason_recruit(
        &mut self,
        mason_leader: CharacterId,
        recruiting: CharacterId,
    ) -> Result<ActionResult> {
        if self.village.character_by_id(recruiting)?.is_village() {
            if let Some(masons) = self.action_queue.iter_mut().find_map(|a| match a {
                ActionPrompt::MasonsWake { leader, masons, .. } => {
                    (leader.character_id == mason_leader).then_some(masons)
                }
                _ => None,
            }) {
                let mut ext_masons = masons.to_vec();
                ext_masons.push(self.village.character_by_id(recruiting)?.identity());
                *masons = ext_masons.into_boxed_slice();
            } else {
                self.action_queue.push_front(ActionPrompt::MasonsWake {
                    leader: self.village.character_by_id(mason_leader)?.identity(),
                    masons: Box::new([self.village.character_by_id(recruiting)?.identity()]),
                });
            }
            Ok(ActionResult::Continue)
        } else {
            Ok(ActionResult::GoBackToSleep)
        }
    }

    fn apply_shapeshift(&mut self, source: &CharacterId) -> Result<()> {
        if let Some(kill_target) = self
            .changes_from_actions()
            .into_iter()
            .find_map(|c| match c {
                NightChange::Kill {
                    target,
                    died_to:
                        DiedTo::Wolfpack {
                            night: _,
                            killing_wolf: _,
                        },
                } => Some(target),
                _ => None,
            })
        {
            if self.changes_from_actions().into_iter().any(|c| match c {
                NightChange::Protection {
                    target,
                    protection: _,
                } => target == kill_target,
                _ => false,
            }) {
                // there is protection, so the kill doesn't happen -> no shapeshift
                return Ok(());
            }

            if self.changes_from_actions().into_iter().any(|c| {
                matches!(
                    c,
                    NightChange::Kill {
                        target: _,
                        died_to: DiedTo::Wolfpack {
                            night: _,
                            killing_wolf: _
                        }
                    }
                )
            }) {
                match &mut self.night_state {
                    NightState::Active {
                        current_changes, ..
                    } => current_changes.push(NightChange::Kill {
                        target: *source,
                        died_to: DiedTo::Shapeshift {
                            into: kill_target,
                            night: NonZeroU8::new(self.night).unwrap(),
                        },
                    }),
                    _ => return Err(GameError::InvalidMessageForGameState),
                }
            }
            match &mut self.night_state {
                NightState::Active {
                    current_changes, ..
                } => current_changes.push(NightChange::Shapeshift {
                    source: *source,
                    into: kill_target,
                }),
                _ => return Err(GameError::InvalidMessageForGameState),
            }
            self.action_queue.push_front(ActionPrompt::RoleChange {
                new_role: RoleTitle::Werewolf,
                character_id: self.village.character_by_id(kill_target)?.identity(),
            });
        }
        // Remove any further shapeshift prompts from the queue
        let mut new_queue = VecDeque::new();
        while let Some(prompt) = self.action_queue.pop_back() {
            match &prompt {
                ActionPrompt::Shapeshifter { character_id: _ } => {}
                _ => new_queue.push_front(prompt),
            }
        }
        self.action_queue = new_queue;
        Ok(())
    }

    pub const fn page(&self) -> Option<usize> {
        match &self.night_state {
            NightState::Active { current_page, .. } => Some(*current_page),
            NightState::Complete => None,
        }
    }

    pub fn received_response(&mut self, resp: ActionResponse) -> Result<ServerAction> {
        match self.received_response_with_role_blocks(resp)? {
            BlockResolvedOutcome::PromptUpdate(prompt) => match &mut self.night_state {
                NightState::Active {
                    current_result: Some(_),
                    ..
                } => Err(GameError::AwaitingResponse),
                NightState::Active { current_prompt, .. } => {
                    *current_prompt = prompt.clone();
                    Ok(ServerAction::Prompt(prompt))
                }
                NightState::Complete => Err(GameError::NightOver),
            },
            BlockResolvedOutcome::ActionComplete(mut result, Some(change)) => {
                match &mut self.night_state {
                    NightState::Active {
                        current_prompt: _,
                        current_result,
                        ..
                    } => current_result.replace(result.clone()),
                    NightState::Complete => return Err(GameError::NightOver),
                };
                if let NightChange::Shapeshift { source, .. } = &change {
                    // needs to be resolved _now_ so that the target can be woken
                    // for the role change with the wolves
                    self.apply_shapeshift(source)?;
                    return Ok(ServerAction::Result(
                        self.action_queue
                            .iter()
                            .next()
                            .and_then(|a| a.is_wolfy().then_some(ActionResult::Continue))
                            .unwrap_or(ActionResult::GoBackToSleep),
                    ));
                }
                if let NightChange::MasonRecruit {
                    mason_leader,
                    recruiting,
                } = &change
                {
                    result = self.apply_mason_recruit(*mason_leader, *recruiting)?;
                }
                match &mut self.night_state {
                    NightState::Active {
                        current_changes, ..
                    } => current_changes.push(change),
                    NightState::Complete => return Err(GameError::InvalidMessageForGameState),
                }
                Ok(ServerAction::Result(result))
            }
            BlockResolvedOutcome::ActionComplete(result, None) => {
                match &mut self.night_state {
                    NightState::Active {
                        current_prompt: _,
                        current_result,
                        ..
                    } => {
                        current_result.replace(result.clone());
                    }
                    NightState::Complete => return Err(GameError::NightOver),
                };
                Ok(ServerAction::Result(result))
            }
        }
    }

    fn received_response_consecutive_wolves_dont_sleep(
        &self,
        resp: ActionResponse,
    ) -> Result<ResponseOutcome> {
        let (current_cover, current_wolfy) = self
            .current_prompt()
            .map(|(current_prompt, _)| {
                (
                    *current_prompt == ActionPrompt::CoverOfDarkness,
                    current_prompt.is_wolfy(),
                )
            })
            .unwrap_or_default();
        let next_wolfy = self
            .action_queue
            .iter()
            .next()
            .map(|a| a.is_wolfy())
            .unwrap_or_default();

        if current_cover && let ActionResponse::Continue = &resp {
            return Ok(ResponseOutcome::ActionComplete(ActionComplete {
                result: ActionResult::Continue,
                change: None,
            }));
        }

        match (self.process(resp)?, current_wolfy, next_wolfy) {
            (ResponseOutcome::PromptUpdate(p), _, _) => Ok(ResponseOutcome::PromptUpdate(p)),
            (
                ResponseOutcome::ActionComplete(ActionComplete {
                    result: ActionResult::GoBackToSleep,
                    change: Some(NightChange::Shapeshift { source, into }),
                }),
                true,
                _,
            ) => Ok(ResponseOutcome::ActionComplete(ActionComplete {
                result: ActionResult::Continue,
                change: Some(NightChange::Shapeshift { source, into }),
            })),
            (
                ResponseOutcome::ActionComplete(ActionComplete {
                    result: ActionResult::GoBackToSleep,
                    change,
                }),
                true,
                true,
            ) => Ok(ResponseOutcome::ActionComplete(ActionComplete {
                result: ActionResult::Continue,
                change,
            })),
            (outcome, _, _) => Ok(outcome),
        }
    }

    fn received_response_with_role_blocks(
        &self,
        resp: ActionResponse,
    ) -> Result<BlockResolvedOutcome> {
        match self.received_response_consecutive_wolves_dont_sleep(resp)? {
            ResponseOutcome::PromptUpdate(update) => Ok(BlockResolvedOutcome::PromptUpdate(update)),
            ResponseOutcome::ActionComplete(ActionComplete { result, change }) => {
                match self
                    .current_prompt()
                    .ok_or(GameError::NightOver)?
                    .0
                    .unless()
                {
                    Some(Unless::TargetBlocked(unless_blocked)) => {
                        if self.changes_from_actions().into_iter().any(|c| match c {
                            NightChange::RoleBlock {
                                source: _,
                                target,
                                block_type: _,
                            } => target == unless_blocked,
                            _ => false,
                        }) {
                            Ok(BlockResolvedOutcome::ActionComplete(
                                ActionResult::RoleBlocked,
                                None,
                            ))
                        } else {
                            Ok(BlockResolvedOutcome::ActionComplete(result, change))
                        }
                    }
                    Some(Unless::TargetsBlocked(unless_blocked1, unless_blocked2)) => {
                        if self.changes_from_actions().into_iter().any(|c| match c {
                            NightChange::RoleBlock {
                                source: _,
                                target,
                                block_type: _,
                            } => target == unless_blocked1 || target == unless_blocked2,
                            _ => false,
                        }) {
                            Ok(BlockResolvedOutcome::ActionComplete(
                                ActionResult::RoleBlocked,
                                None,
                            ))
                        } else {
                            Ok(BlockResolvedOutcome::ActionComplete(result, change))
                        }
                    }
                    None => Ok(BlockResolvedOutcome::ActionComplete(result, change)),
                }
            }
        }
    }

    pub const fn village(&self) -> &Village {
        &self.village
    }

    pub const fn current_result(&self) -> Option<&ActionResult> {
        match &self.night_state {
            NightState::Active {
                current_prompt: _,
                current_result,
                ..
            } => current_result.as_ref(),
            NightState::Complete => None,
        }
    }

    pub const fn current_prompt(&self) -> Option<(&ActionPrompt, usize)> {
        match &self.night_state {
            NightState::Active {
                current_prompt,
                current_result: _,
                current_page,
                ..
            } => Some((current_prompt, *current_page)),
            NightState::Complete => None,
        }
    }

    pub const fn current_character_id(&self) -> Option<CharacterId> {
        match &self.night_state {
            NightState::Active {
                current_prompt,
                current_result: _,
                ..
            } => match current_prompt {
                ActionPrompt::Insomniac { character_id, .. }
                | ActionPrompt::LoneWolfKill { character_id, .. }
                | ActionPrompt::ElderReveal { character_id }
                | ActionPrompt::RoleChange { character_id, .. }
                | ActionPrompt::Seer { character_id, .. }
                | ActionPrompt::Protector { character_id, .. }
                | ActionPrompt::Arcanist { character_id, .. }
                | ActionPrompt::Gravedigger { character_id, .. }
                | ActionPrompt::Hunter { character_id, .. }
                | ActionPrompt::Militia { character_id, .. }
                | ActionPrompt::MapleWolf { character_id, .. }
                | ActionPrompt::Guardian { character_id, .. }
                | ActionPrompt::Shapeshifter { character_id }
                | ActionPrompt::AlphaWolf { character_id, .. }
                | ActionPrompt::Adjudicator { character_id, .. }
                | ActionPrompt::PowerSeer { character_id, .. }
                | ActionPrompt::Mortician { character_id, .. }
                | ActionPrompt::Beholder { character_id, .. }
                | ActionPrompt::MasonLeaderRecruit { character_id, .. }
                | ActionPrompt::Empath { character_id, .. }
                | ActionPrompt::Vindicator { character_id, .. }
                | ActionPrompt::PyreMaster { character_id, .. }
                | ActionPrompt::DireWolf { character_id, .. } => Some(character_id.character_id),

                ActionPrompt::WolvesIntro { wolves: _ }
                | ActionPrompt::MasonsWake { .. }
                | ActionPrompt::WolfPackKill { .. }
                | ActionPrompt::CoverOfDarkness => None,
            },
            NightState::Complete => None,
        }
    }

    pub fn current_character(&self) -> Option<&Character> {
        self.current_character_id()
            .and_then(|id| self.village.character_by_id(id).ok())
    }

    pub const fn complete(&self) -> bool {
        matches!(self.night_state, NightState::Complete)
    }

    pub fn used_actions(&self) -> Box<[(ActionPrompt, ActionResult)]> {
        self.used_actions
            .iter()
            .map(|(p, r, _)| (p.clone(), r.clone()))
            .collect()
    }

    pub fn next(&mut self) -> Result<()> {
        match &self.night_state {
            NightState::Active {
                current_prompt,
                current_result: Some(result),
                current_changes,
                ..
            } => {
                self.used_actions.push((
                    current_prompt.clone(),
                    result.clone(),
                    current_changes.clone(),
                ));
            }
            NightState::Active {
                current_prompt: _,
                current_result: None,
                ..
            } => return Err(GameError::AwaitingResponse),
            NightState::Complete => return Err(GameError::NightOver),
        }
        if let Some(prompt) = self.action_queue.pop_front() {
            if let ActionPrompt::Insomniac { character_id } = &prompt
                && self.get_visits_for(character_id.character_id).is_empty()
            {
                // skip!
                self.used_actions.pop(); // it will be re-added
                return self.next();
            }
            self.night_state = NightState::Active {
                current_prompt: prompt,
                current_result: None,
                current_changes: Vec::new(),
                current_page: 0,
            };
        } else {
            self.night_state = NightState::Complete;
        }

        Ok(())
    }

    fn changes_from_actions(&self) -> Box<[NightChange]> {
        self.used_actions
            .iter()
            .flat_map(|(_, _, act)| act.iter())
            .cloned()
            .collect()
    }

    pub fn get_visits_for(&self, visit_char: CharacterId) -> Visits {
        Visits::new(
            self.used_actions
                .iter()
                .filter_map(|(prompt, _, _)| match prompt {
                    ActionPrompt::Arcanist {
                        character_id,
                        marked: (Some(marked1), Some(marked2)),
                        ..
                    } => (*marked1 == visit_char || *marked2 == visit_char)
                        .then_some(character_id.clone()),
                    ActionPrompt::WolfPackKill {
                        marked: Some(marked),
                        ..
                    } => (*marked == visit_char)
                        .then(|| self.village.killing_wolf().map(|c| c.identity()))
                        .flatten(),

                    ActionPrompt::Seer {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Protector {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Gravedigger {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Hunter {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Militia {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::MapleWolf {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Guardian {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Adjudicator {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::PowerSeer {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Mortician {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Beholder {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::MasonLeaderRecruit {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Empath {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::Vindicator {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::PyreMaster {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::AlphaWolf {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::DireWolf {
                        character_id,
                        marked: Some(marked),
                        ..
                    }
                    | ActionPrompt::LoneWolfKill {
                        character_id,
                        marked: Some(marked),
                        ..
                    } => (*marked == visit_char).then(|| character_id.clone()),

                    ActionPrompt::WolfPackKill { marked: None, .. }
                    | ActionPrompt::Arcanist { marked: _, .. }
                    | ActionPrompt::LoneWolfKill { marked: None, .. }
                    | ActionPrompt::Seer { marked: None, .. }
                    | ActionPrompt::Protector { marked: None, .. }
                    | ActionPrompt::Gravedigger { marked: None, .. }
                    | ActionPrompt::Hunter { marked: None, .. }
                    | ActionPrompt::Militia { marked: None, .. }
                    | ActionPrompt::MapleWolf { marked: None, .. }
                    | ActionPrompt::Guardian { marked: None, .. }
                    | ActionPrompt::Adjudicator { marked: None, .. }
                    | ActionPrompt::PowerSeer { marked: None, .. }
                    | ActionPrompt::Mortician { marked: None, .. }
                    | ActionPrompt::Beholder { marked: None, .. }
                    | ActionPrompt::MasonLeaderRecruit { marked: None, .. }
                    | ActionPrompt::Empath { marked: None, .. }
                    | ActionPrompt::Vindicator { marked: None, .. }
                    | ActionPrompt::PyreMaster { marked: None, .. }
                    | ActionPrompt::AlphaWolf { marked: None, .. }
                    | ActionPrompt::DireWolf { marked: None, .. }
                    | ActionPrompt::CoverOfDarkness
                    | ActionPrompt::WolvesIntro { .. }
                    | ActionPrompt::RoleChange { .. }
                    | ActionPrompt::ElderReveal { .. }
                    | ActionPrompt::Shapeshifter { .. }
                    | ActionPrompt::MasonsWake { .. }
                    | ActionPrompt::Insomniac { .. } => None,
                })
                .collect(),
        )
    }

    pub fn next_page(&mut self) {
        if let NightState::Active { current_page, .. } = &mut self.night_state {
            *current_page += 1
        }
    }
}

pub enum ServerAction {
    Prompt(ActionPrompt),
    Result(ActionResult),
}

mod filter {
    use crate::character::Character;

    pub fn no_filter(_: &Character) -> bool {
        true
    }

    pub fn no_village(c: &Character) -> bool {
        !c.is_village()
    }
}