Geoffrey-rs/geoffrey_models/src/models/locations/mod.rs

use serde::{Deserialize, Serialize};
use std::collections::HashSet;

use crate::models::{Position, Tunnel};
use crate::GeoffreyDatabaseModel;
use crate::models::locations::shop::Shop;
use crate::models::locations::town::{TownDb, Town};
use crate::models::locations::farm::FarmData;
use crate::models::locations::market::{MarketDb, Market};
use crate::models::player::Player;

pub mod farm;
pub mod market;
pub mod shop;
pub mod town;

#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
pub enum LocationType {
    Base,
    Shop,
    Attraction,
    Town,
    Farm,
    Market,
}

impl From<LocationDataDb> for LocationType {
    fn from(l: LocationDataDb) -> Self {
        match l {
            LocationDataDb::Base => LocationType::Base,
            LocationDataDb::Shop(_) => LocationType::Shop,
            LocationDataDb::Attraction => LocationType::Attraction,
            LocationDataDb::Town(_) => LocationType::Town,
            LocationDataDb::Farm(_) => LocationType::Farm,
            LocationDataDb::Market(_) => LocationType::Market,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum LocationDataDb {
    Base,
    Shop(Shop),
    Attraction,
    Town(TownDb),
    Farm(FarmData),
    Market(MarketDb),
}

impl From<LocationType> for LocationDataDb {
    fn from(t: LocationType) -> Self {
        match t {
            LocationType::Base => LocationDataDb::Base,
            LocationType::Shop => LocationDataDb::Shop(Default::default()),
            LocationType::Attraction => LocationDataDb::Attraction,
            LocationType::Town => LocationDataDb::Town(Default::default()),
            LocationType::Farm => LocationDataDb::Farm(Default::default()),
            LocationType::Market => LocationDataDb::Market(Default::default())
        }
    }
}


#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum  LocationData {
    Base,
    Shop(Shop),
    Attraction,
    Town(Town),
    Farm(FarmData),
    Market(Market),
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LocationDb {
    id: Option<u64>,
    pub name: String,
    pub position: Position,
    owners: HashSet<u64>,
    pub tunnel: Option<Tunnel>,
    pub loc_data: LocationDataDb,
}

impl LocationDb {
    pub fn new(
        name: &str,
        position: Position,
        owner: u64,
        tunnel: Option<Tunnel>,
        loc_type: LocationDataDb,
    ) -> Self {
        let mut owners = HashSet::new();
        owners.insert(owner);

        Self {
            id: None,
            name: name.to_string(),
            position,
            owners,
            tunnel,
            loc_data: loc_type,
        }
    }

    pub fn owners(&self) -> Vec<u64> {
        self.owners.iter().cloned().collect()
    }

    pub fn add_owner(&mut self, owner: u64) {
        self.owners.insert(owner);
    }

    pub fn remove_owner(&mut self, owner: u64) {
        self.owners.remove(&owner);
    }
}

impl GeoffreyDatabaseModel for LocationDb {
    fn id(&self) -> Option<u64> {
        self.id
    }

    fn set_id(&mut self, id: u64) {
        self.id = Some(id)
    }

    fn tree() -> String {
        "location".to_string()
    }

    fn check_unique(&self, o: &Self) -> bool {
        o.name.to_lowercase() != self.name.to_lowercase()
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Location {
    pub id: u64,
    pub name: String,
    pub position: Position,
    pub owners: Vec<Player>,
    pub tunnel: Option<Tunnel>,
    pub loc_data: LocationData,
}

impl Location {
    pub fn from_db_location(location: LocationDb, owners: Vec<Player>, loc_data: LocationData) -> Self {
        Self {
            id: location.id.unwrap(),
            name: location.name,
            position: location.position,
            owners,
            tunnel: location.tunnel,
            loc_data
        }
    }
}


#[cfg(test)]
mod tests {
    use crate::models::locations::{LocationDb, LocationDataDb};
    use crate::models::{Dimension, Position};
    use crate::GeoffreyDatabaseModel;

    #[test]
    fn test_location_check_unique() {
        let l1 = LocationDb::new(
            "Test",
            Position::new(0, 0, Dimension::Overworld),
            0u64,
            None,
            LocationDataDb::Base,
        );
        let l2 = LocationDb::new(
            "NotTest",
            Position::new(0, 0, Dimension::Overworld),
            0u64,
            None,
            LocationDataDb::Base,
        );

        assert!(l1.check_unique(&l2));

        let l1 = LocationDb::new(
            "Test",
            Position::new(0, 0, Dimension::Overworld),
            0u64,
            None,
            LocationDataDb::Base,
        );
        let l2 = LocationDb::new(
            "teSt",
            Position::new(0, 0, Dimension::Overworld),
            0u64,
            None,
            LocationDataDb::Base,
        );

        assert!(!l1.check_unique(&l2));
    }
}