// Copyright (C) 2025-2026 Emilis Bliūdžius
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
use core::{
    num::NonZeroU8,
    ops::{Deref, DerefMut},
};

use tokio::sync::broadcast::Sender;
use werewolves_proto::{
    error::GameError,
    game::{Game, GameSettings},
    message::{
        ClientMessage, Identification, PlayerState, PublicIdentity, ServerMessage,
        host::{HostLobbyMessage, HostMessage, ServerToHostMessage},
    },
    player::PlayerId,
};

use crate::{
    LogError,
    communication::lobby::LobbyComms,
    connection::JoinedPlayers,
    game::GameRunner,
    runner::{ClientUpdate, IdentifiedClientMessage, Message},
};

pub struct Lobby {
    players_in_lobby: LobbyPlayers,
    settings: GameSettings,
    joined_players: JoinedPlayers,
    comms: Option<LobbyComms>,
    qr_mode: bool,
}

impl Lobby {
    pub fn new(joined_players: JoinedPlayers, comms: LobbyComms) -> Self {
        Self {
            joined_players,
            comms: Some(comms),
            settings: GameSettings::default(),
            players_in_lobby: LobbyPlayers(Vec::new()),
            qr_mode: false,
        }
    }

    pub fn set_settings(&mut self, settings: GameSettings) {
        self.settings = settings.clone();
    }

    pub fn set_players_in_lobby(&mut self, players_in_lobby: LobbyPlayers) {
        self.players_in_lobby = players_in_lobby
    }

    const fn comms(&mut self) -> Result<&mut LobbyComms, GameError> {
        match self.comms.as_mut() {
            Some(comms) => Ok(comms),
            None => Err(GameError::InactiveGameObject),
        }
    }

    pub async fn send_lobby_info_to_clients(&mut self) {
        let players = self
            .players_in_lobby
            .iter()
            .map(|(id, _)| id.public.clone())
            .collect::<Box<[_]>>();
        self.joined_players
            .send_all_lobby(
                players,
                &self
                    .players_in_lobby
                    .iter()
                    .map(|(id, _)| id.player_id)
                    .collect::<Box<[_]>>(),
            )
            .await;
    }

    async fn get_lobby_info(&self) -> Box<[PlayerState]> {
        let mut players = Vec::new();
        for (player, _) in self.players_in_lobby.iter() {
            players.push(PlayerState {
                identification: player.clone(),
                connected: self.joined_players.is_connected(player.player_id).await,
            });
        }

        players.into_boxed_slice()
    }

    pub async fn send_lobby_info_to_host(&mut self) -> Result<(), GameError> {
        let players = self.get_lobby_info().await;
        let qr_mode = self.qr_mode;
        let settings = self.settings.clone();
        let host = self.comms()?.host();
        host.send(ServerToHostMessage::Lobby { players, settings })?;
        host.send(ServerToHostMessage::QrMode(qr_mode))
    }

    pub async fn next(&mut self) -> Option<GameRunner> {
        let msg = match self.comms().unwrap().next_message().await {
            Ok(msg) => msg,
            Err(err) => {
                log::error!("get next message: {err}");
                return None;
            }
        };

        match self.next_inner(msg.clone()).await.map_err(|err| (msg, err)) {
            Ok(None) => {}
            Ok(Some(mut game)) => {
                game.role_reveal().await;
                match game.host_message(HostMessage::GetState) {
                    Ok(msg) => {
                        log::info!("initial message after night reveal: {msg:?}");
                        game.comms().host().send(msg).log_warn();
                    }
                    Err(err) => {
                        log::error!("processing get_state after role reveal to host: {err}")
                    }
                }

                return Some(game);
            }
            Err((Message::Host(_), err)) => self
                .comms()
                .unwrap()
                .host()
                .send(ServerToHostMessage::Error(err))
                .log_warn(),
            Err((
                Message::Client(IdentifiedClientMessage {
                    identity: Identification { player_id, .. },
                    ..
                }),
                GameError::InvalidMessageForGameState,
            )) => {
                let _ = self
                    .players_in_lobby
                    .send_if_present(player_id, ServerMessage::InvalidMessageForGameState);
            }
            Err((
                Message::Client(IdentifiedClientMessage {
                    update: ClientUpdate::ConnectStateUpdate,
                    ..
                }),
                _,
            )) => {}
            Err((
                Message::Client(IdentifiedClientMessage {
                    identity: Identification { player_id, public },
                    ..
                }),
                err,
            )) => {
                log::error!("processing message from {public} [{player_id}]: {err}");
                let _ = self
                    .players_in_lobby
                    .send_if_present(player_id, ServerMessage::Reset);
            }
        }
        None
    }

    async fn next_inner(&mut self, msg: Message) -> Result<Option<GameRunner>, GameError> {
        match msg {
            Message::Host(HostMessage::Lobby(HostLobbyMessage::ManufacturePlayer(public))) => {
                log::info!("adding player {public:?} by host request");
                self.players_in_lobby.push((
                    Identification {
                        player_id: PlayerId::new(),
                        public,
                    },
                    None,
                ));
                self.send_lobby_info_to_clients().await;
                self.send_lobby_info_to_host().await.log_debug();
            }
            Message::Host(HostMessage::Lobby(HostLobbyMessage::SetQrMode(mode))) => {
                self.qr_mode = mode;
                self.send_lobby_info_to_host().await.log_debug();
            }
            Message::Host(HostMessage::InGame(_))
            | Message::Host(HostMessage::ForceRoleAckFor(_)) => {
                return Err(GameError::InvalidMessageForGameState);
            }
            Message::Host(HostMessage::PostGame(_)) => self
                .comms()
                .unwrap()
                .host()
                .send(ServerToHostMessage::Error(
                    GameError::InvalidMessageForGameState,
                ))
                .log_warn(),
            Message::Host(HostMessage::Lobby(HostLobbyMessage::GetState))
            | Message::Host(HostMessage::GetState) => {
                self.send_lobby_info_to_host().await?;
            }
            Message::Host(HostMessage::Lobby(HostLobbyMessage::SetGameSettings(settings))) => {
                self.settings = settings;
                self.send_lobby_info_to_host().await?;
            }
            Message::Host(HostMessage::Lobby(HostLobbyMessage::SetPlayerNumber(pid, num))) => {
                self.joined_players
                    .update(&pid, |p| p.number = Some(num))
                    .await;
                if let Some(p) = self
                    .players_in_lobby
                    .iter_mut()
                    .find_map(|(c, _)| (c.player_id == pid).then_some(c))
                    && let Some(joined_id) = self.joined_players.get_player_identity(pid).await
                {
                    p.public = joined_id;
                }
                self.send_lobby_info_to_clients().await;
                self.send_lobby_info_to_host().await.log_debug();
            }
            Message::Host(HostMessage::Lobby(HostLobbyMessage::Start)) => {
                let playing_players = self
                    .players_in_lobby
                    .iter()
                    .map(|(id, _)| id.clone())
                    .collect::<Box<[_]>>();
                self.settings.check_with_player_list(&playing_players)?;

                let game = Game::new(&playing_players, self.settings.clone())?;
                assert_eq!(game.village().characters().len(), playing_players.len());

                let comms = self.comms.take().unwrap().into_inner();
                return Ok(Some(GameRunner::new(
                    game,
                    comms,
                    self.players_in_lobby.clone(),
                    self.joined_players.clone(),
                )));
            }
            Message::Client(IdentifiedClientMessage {
                identity,
                update: ClientUpdate::Message(ClientMessage::Hello),
            }) => {
                if self
                    .players_in_lobby
                    .iter_mut()
                    .any(|p| p.0.player_id == identity.player_id)
                {
                    // Already have the player
                    return Ok(None);
                }
                if let Some(sender) = self.joined_players.get_sender(identity.player_id).await {
                    self.players_in_lobby.push((identity, Some(sender.clone())));
                    self.send_lobby_info_to_clients().await;
                    self.send_lobby_info_to_host().await?;
                }
            }
            Message::Host(HostMessage::Lobby(HostLobbyMessage::Kick(player_id)))
            | Message::Client(IdentifiedClientMessage {
                identity: Identification { player_id, .. },
                update: ClientUpdate::Message(ClientMessage::Goodbye),
            }) => {
                if let Some(remove_idx) = self
                    .players_in_lobby
                    .iter()
                    .enumerate()
                    .find_map(|(idx, p)| (p.0.player_id == player_id).then_some(idx))
                {
                    self.players_in_lobby.swap_remove(remove_idx);
                    self.send_lobby_info_to_host().await?;
                    self.send_lobby_info_to_clients().await;
                }
            }
            Message::Client(IdentifiedClientMessage {
                identity: Identification { player_id, .. },
                update: ClientUpdate::Message(ClientMessage::GetState),
            }) => {
                let msg = ServerMessage::LobbyInfo {
                    joined: self
                        .players_in_lobby
                        .iter()
                        .any(|(p, _)| p.player_id == player_id),
                    players: self
                        .players_in_lobby
                        .iter()
                        .map(|(id, _)| id.public.clone())
                        .collect(),
                };
                if let Some(sender) = self.joined_players.get_sender(player_id).await {
                    sender.send(msg).log_debug();
                }
            }
            Message::Client(IdentifiedClientMessage {
                update: ClientUpdate::Message(ClientMessage::RoleAck),
                ..
            }) => return Err(GameError::InvalidMessageForGameState),
            Message::Client(IdentifiedClientMessage {
                identity: Identification { player_id, public },
                update: ClientUpdate::Message(ClientMessage::UpdateSelf(_)),
            }) => {
                self.joined_players
                    .update(&player_id, |p| {
                        p.name = public.name.clone();
                        p.number = public.number;
                        p.pronouns = public.pronouns.clone();
                    })
                    .await;
                if let Some(p) = self
                    .players_in_lobby
                    .iter_mut()
                    .find_map(|(c, _)| (c.player_id == player_id).then_some(c))
                {
                    p.public = public;
                }
                self.send_lobby_info_to_clients().await;
                self.send_lobby_info_to_host().await.log_debug();
            }
            Message::Client(IdentifiedClientMessage {
                update: ClientUpdate::ConnectStateUpdate,
                ..
            }) => self.send_lobby_info_to_host().await?,
            Message::Host(HostMessage::Echo(msg)) => {
                self.comms()?.host().send(msg).log_warn();
            }
        }

        Ok(None)
    }
}

#[derive(Clone)]
pub struct LobbyPlayers(Vec<(Identification, Option<Sender<ServerMessage>>)>);

impl Deref for LobbyPlayers {
    type Target = Vec<(Identification, Option<Sender<ServerMessage>>)>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for LobbyPlayers {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl LobbyPlayers {
    pub fn with_dummies(dummy_count: NonZeroU8) -> Self {
        Self(
            (0..dummy_count.get())
                .map(|p| {
                    (
                        Identification {
                            player_id: PlayerId::from_u128(p as u128 + 1),
                            public: PublicIdentity {
                                name: format!("Player {}", p as u16 + 1),
                                pronouns: Some(String::from("he/him")),
                                number: NonZeroU8::new(p + 1),
                            },
                        },
                        None,
                    )
                })
                .collect(),
        )
    }
    pub fn find(&self, player_id: PlayerId) -> Option<&Sender<ServerMessage>> {
        self.iter()
            .filter_map(|(id, s)| s.as_ref().map(|s| (id, s)))
            .find_map(|(id, s)| (id.player_id == player_id).then_some(s))
    }

    pub fn send_if_present(
        &self,
        player_id: PlayerId,
        message: ServerMessage,
    ) -> Result<bool, GameError> {
        if let Some(sender) = self.find(player_id) {
            sender
                .send(message)
                .map_err(|err| GameError::GenericError(err.to_string()))?;
            Ok(true)
        } else {
            Ok(false)
        }
    }
}