/*
    Hurry Curry! - a game about cooking
    Copyright 2025 metamuffin

    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, version 3 of the License only.

    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/>.

*/
pub mod book;
pub mod bot;
pub mod campaign;
pub mod conveyor;
pub mod customers;
pub mod environment_effect;
pub mod item_portal;
pub mod player_portal;
pub mod tram;
pub mod tutorial;

use crate::{
    data::{ItemTileRegistry, Serverdata},
    message::TrError,
    scoreboard::ScoreboardStore,
};
use anyhow::{anyhow, Result};
use book::Book;
use campaign::{Gate, GateCondition, Map};
use conveyor::Conveyor;
use customers::Customers;
use environment_effect::{EnvironmentController, EnvironmentEffect, EnvironmentEffectController};
use hurrycurry_client_lib::Game;
use hurrycurry_protocol::{
    glam::{IVec2, Vec2},
    PacketC, PacketS, PlayerID,
};
use item_portal::ItemPortal;
use player_portal::PlayerPortal;
use serde::{Deserialize, Serialize};
use std::{any::Any, collections::VecDeque};
use tram::Tram;

pub type DynEntity = Box<dyn Entity + Send + Sync + 'static>;
pub type Entities = Vec<DynEntity>;

pub struct EntityContext<'a> {
    pub game: &'a mut Game,
    pub serverdata: &'a Serverdata,
    pub packet_out: &'a mut VecDeque<PacketC>,
    pub packet_in: &'a mut VecDeque<PacketS>,
    pub score_changed: &'a mut bool,
    pub load_map: &'a mut Option<String>,
    pub scoreboard: &'a ScoreboardStore,
    pub replies: Option<&'a mut Vec<PacketC>>,
    pub dt: f32,
}

pub trait Entity: Any {
    fn tick(&mut self, _c: EntityContext<'_>) -> Result<()> {
        Ok(())
    }
    fn finished(&self) -> bool {
        false
    }
    fn destructor(&mut self, _c: EntityContext<'_>) {}
    fn interact(
        &mut self,
        _c: EntityContext<'_>,
        _pos: Option<IVec2>,
        _player: PlayerID,
    ) -> Result<bool, TrError> {
        Ok(false)
    }
}

// macro_rules! entities {
//     ($($e:ident),*) => {
//         pub enum DynEntity { $($e($e)),* }
//         impl Entity for DynEntity {
//             fn tick(&mut self, c: EntityContext<'_>) -> Result<()> {
//                 match self { $(DynEntity::$e(x) => x.tick(c)),*, }
//             }
//             fn destructor(&mut self, c: EntityContext<'_>) {
//                 match self { $(DynEntity::$e(x) => x.destructor(c)),*, }
//             }
//         }
//     };
// }
// entities!(
//     Conveyor,
//     ItemPortal,
//     PlayerPortal,
//     Customers,
//     EnvironmentEffectController,
//     EnvironmentController
// );

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum EntityDecl {
    Conveyor {
        from: Option<IVec2>,
        to: Option<IVec2>,
        filter_dir: Option<IVec2>,
        filter: Option<String>,
        dir: Option<IVec2>,
        speed: Option<f32>,
    },
    ItemPortal {
        from: Option<IVec2>,
        to: IVec2,
    },
    PlayerPortal {
        from: Option<Vec2>,
        to: Vec2,
    },
    Customers {
        scaling_factor: Option<f32>,
    },
    Map {
        name: String,
        location: Option<Vec2>,
    },
    EnvironmentEffect(EnvironmentEffect),
    Environment(Vec<String>),
    Gate {
        location: Option<IVec2>,
        condition: GateCondition,
    },
    Tram {
        length: usize,
        character: Option<i32>,
        points: Vec<Vec2>,
        spacing: f32,
        smoothing: f32,
    },
    Book,
}

pub fn construct_entity(
    pos: Option<IVec2>,
    decl: &EntityDecl,
    reg: &ItemTileRegistry,
) -> Result<DynEntity> {
    Ok(match decl.to_owned() {
        EntityDecl::Book => Box::new(Book(pos.ok_or(anyhow!("book is tile entity"))?)),
        EntityDecl::ItemPortal { from, to } => Box::new(ItemPortal {
            from: from
                .or(pos)
                .ok_or(anyhow!("Item portal start without start"))?,
            to,
        }),
        EntityDecl::PlayerPortal { from, to } => Box::new(PlayerPortal {
            from: from
                .or(pos.map(|v| v.as_vec2()))
                .ok_or(anyhow!("Player portal without start"))?,
            to,
        }),
        EntityDecl::Conveyor {
            from,
            to,
            speed,
            dir,
            filter,
            filter_dir,
        } => {
            let from = from.or(pos).ok_or(anyhow!("Conveyor has no start"))?;
            let to = to
                .or(dir.map(|s| s + from))
                .ok_or(anyhow!("Conveyor has no destination"))?;
            Box::new(Conveyor {
                from,
                to,
                max_cooldown: 1. / speed.unwrap_or(2.),
                filter_tile: filter_dir.map(|o| to + o),
                filter_item: filter.map(|name| reg.register_item(name)),
                cooldown: 0.,
            })
        }
        EntityDecl::Map { name, location } => Box::new(Map {
            location: location
                .or(pos.map(|p| p.as_vec2() + 0.5))
                .ok_or(anyhow!("no location"))?,
            name,
        }),
        EntityDecl::Gate {
            condition,
            location,
        } => Box::new(Gate {
            condition,
            unlocked: false,
            location: location.or(pos).ok_or(anyhow!("no location"))?,
            blocker_tile: reg.register_tile("fence".to_string()),
            active: true,
        }),
        EntityDecl::Customers { scaling_factor } => {
            reg.register_item("unknown-order".to_owned());
            Box::new(Customers::new(scaling_factor.unwrap_or(0.5))?)
        }
        EntityDecl::EnvironmentEffect(config) => Box::new(EnvironmentEffectController::new(config)),
        EntityDecl::Environment(names) => Box::new(EnvironmentController(names)),
        EntityDecl::Tram {
            length,
            character,
            points,
            smoothing,
            spacing,
        } => Box::new(Tram {
            length,
            character: character.unwrap_or(51),
            ids: Vec::new(),
            points,
            progress: 0.,
            spacing,
            smoothing,
        }),
    })
}