use crate::database::Database;
use crate::error::{GeoffreyDBError, Result};
use geoffrey_models::models::locations::market::Market;
use geoffrey_models::models::locations::town::Town;
use geoffrey_models::models::locations::{
    Location, LocationData, LocationDataDb, LocationDb, LocationType,
};
use geoffrey_models::models::player::Player;

pub fn load_location_data(db: &Database, data: &LocationDataDb) -> Result<LocationData> {
    Ok(match data {
        LocationDataDb::Base => LocationData::Base,
        LocationDataDb::Shop(shop_data) => LocationData::Shop(shop_data.clone()),
        LocationDataDb::Attraction => LocationData::Attraction,
        LocationDataDb::Town(town_data) => {
            let town_data = Town {
                residents: db
                    .filter(|id, _: &Player| town_data.residents.contains(&id))?
                    .collect(),
            };

            LocationData::Town(town_data)
        }
        LocationDataDb::Farm(farm_data) => LocationData::Farm(farm_data.clone()),
        LocationDataDb::Market(market_data) => {
            let shops: Result<Vec<Location>> = db
                .filter(|id, _: &LocationDb| market_data.shops.contains(&id))?
                .map(|loc| load_location(db, &loc))
                .collect();

            let market_data = Market {
                is_public: market_data.is_public,
                shops: shops?,
            };

            LocationData::Market(market_data)
        }
    })
}

pub fn load_location(db: &Database, location: &LocationDb) -> Result<Location> {
    let owners: Vec<Player> = db
        .filter(|id, _: &Player| location.owners().contains(&id))?
        .collect();
    let loc_data = load_location_data(db, &location.loc_data)?;

    Ok(Location::from_db_location(
        location.clone(),
        owners,
        loc_data,
    ))
}

pub fn find_location_by_name(
    db: &Database,
    location_name: &str,
    owner_id: u64,
) -> Result<LocationDb> {
    let filter = regex::Regex::new(format!(r"(?i)^{}$", location_name).as_str()).unwrap();

    let location: LocationDb = db
        .filter(|_, loc: &LocationDb| {
            loc.owners().contains(&owner_id) && filter.is_match(loc.name.as_str())
        })?
        .next()
        .ok_or(GeoffreyDBError::NotFound)?;

    Ok(location)
}

pub fn find_location_by_name_type(
    db: &Database,
    location_name: &str,
    owner_id: u64,
    loc_type: LocationType,
) -> Result<LocationDb> {
    let filter = regex::Regex::new(format!(r"(?i)^{}$", location_name).as_str()).unwrap();

    let location: LocationDb = db
        .filter(|_, loc: &LocationDb| {
            let lt: LocationType = LocationType::from(&loc.loc_data);
            loc.owners().contains(&owner_id) && filter.is_match(loc.name.as_str()) && lt == loc_type
        })?
        .next()
        .ok_or(GeoffreyDBError::NotFound)?;

    Ok(location)
}