// Traders: now and then a merchant comes through one of the master's portals and waits there
// for a minute. A click with the hand buys what he offers - the plans of a rune forge tower, a
// rare creature, a bundle of wood or a potion that fills the mana. Single player only (in a
// match the masters would have to agree on who buys).

use crate::game::*;
use crate::map::*;
use serde::{Deserialize, Serialize};

// seconds until the first trader, between two traders, and how long one waits
pub const TRADER_FIRST: f32 = 420.0;
pub const TRADER_GAP: f32 = 540.0;
pub const TRADER_WAIT: f32 = 60.0;

// what a trader may offer: (language key, price)
pub const OFFERS: [(&str, f32); 5] = [("trader.rune", 450.0), ("trader.wyrm", 1200.0), ("trader.chainbreaker", 900.0), ("trader.wood", 250.0), ("trader.mana", 200.0)];

#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct Trading {
    pub t: f32,                         // seconds until the next trader comes
    pub here: Option<(u32, u8, f32)>, // the trader on the map: unit id, offer, seconds left
}

impl Game {
    pub(crate) fn update_traders(&mut self, dt: f32) {
        if self.netplay.is_some() || self.demo.is_some() || self.state != 0 {
            return;
        }
        if self.trading.t == 0.0 && self.trading.here.is_none() {
            self.trading.t = TRADER_FIRST;
        }
        if let Some((id, offer, left)) = self.trading.here {
            let left = left - dt;
            if left <= 0.0 || self.find(id).is_none() {
                self.trader_leaves(true);
            } else {
                self.trading.here = Some((id, offer, left));
            }
            return;
        }
        self.trading.t -= dt;
        if self.trading.t > 0.0 {
            return;
        }
        self.trading.t = TRADER_GAP + self.rng.f() * 180.0;
        // he comes through an own portal
        let portals: Vec<(i32, i32)> = (0..self.map.portals.len()).filter(|&k| self.map.portal_owner(k) == self.me).map(|k| self.map.portals[k]).collect();
        let Some(&(px, py)) = portals.get((self.rng.next() as usize) % portals.len().max(1)) else { return };
        let spot = DIR8.iter().map(|&(dx, dy)| (px + 1 + dx * 2, py + 1 + dy * 2)).find(|&(x, y)| self.map.walk(x, y));
        let Some((x, y)) = spot else { return };
        let offer = (self.rng.next() % OFFERS.len() as u32) as u8;
        let id = self.spawn(EK::Trader, false, x as f32 + 0.5, y as f32 + 0.5, 1);
        if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
            e.side = self.me_side;
            e.home = Some((x as f32 + 0.5, y as f32 + 0.5));
            e.settled = true;
            e.happy = 1.0;
        }
        self.trading.here = Some((id, offer, TRADER_WAIT));
        let (key, price) = OFFERS[offer as usize];
        self.msg("msg.trader_arrives", vec![format!("@{}", key), (price as i32).to_string()]);
        self.sfx_ui(Sfx::Deposit);
    }

    // the trader goes back through the portal
    fn trader_leaves(&mut self, unsold: bool) {
        if let Some((id, _, _)) = self.trading.here.take() {
            if let Some(j) = self.find(id) {
                let (x, y) = (self.ents[j].x, self.ents[j].y);
                self.ents[j].alive = false;
                self.fx(7, x, y, 0.0, 0.0, 0.8, 0xffff60c0);
            }
            if unsold {
                self.msg("msg.trader_left", vec![]);
            }
        }
    }

    // the hand on the trader: buy his offer (true: it was the trader)
    pub(crate) fn buy_from_trader(&mut self, j: usize) -> bool {
        let Some((id, offer, _)) = self.trading.here else { return false };
        if self.ents[j].id != id {
            return false;
        }
        let (key, price) = OFFERS[offer as usize];
        if self.gold < price {
            self.msg("msg.no_gold", vec![]);
            self.sfx_ui(Sfx::Error);
            return true;
        }
        self.gold -= price;
        let (x, y) = (self.ents[j].x, self.ents[j].y);
        match offer {
            0 => self.rune_free += 1,
            1 | 2 => {
                let (kind, level) = if offer == 1 { (EK::Wyrm, 3) } else { (EK::Chainbreaker, 4) };
                let nid = self.spawn(kind, false, x, y, level);
                if let Some(e) = self.ents.iter_mut().find(|e| e.id == nid) {
                    e.side = self.me_side;
                    e.settled = false;
                    e.job = Job::Register;
                    e.timer = 1.0;
                    e.happy = 1.0;
                }
            }
            3 => self.wood += 30.0,
            _ => self.mana = self.mana_max(),
        }
        self.msg("msg.trader_sold", vec![format!("@{}", key)]);
        self.sfx_ui(Sfx::Payday);
        self.trader_leaves(false);
        true
    }

    // a trader just stands by the portal and waits
    pub(crate) fn trader_ai(&mut self, e: &mut Ent, dt: f32) {
        e.hunger = 0.0;
        e.energy = 1.0;
        e.happy = 1.0;
        if let Some((hx, hy)) = e.home {
            if (e.x - hx).abs() + (e.y - hy).abs() > 0.3 && e.path.is_empty() {
                e.x = hx;
                e.y = hy;
            }
        }
        let _ = dt;
    }

    // what the trader offers (hover information): (offer key, price, seconds left)
    pub fn trader_offer(&self, id: u32) -> Option<(&'static str, f32, f32)> {
        self.trading.here.filter(|h| h.0 == id).map(|(_, o, left)| (OFFERS[o as usize].0, OFFERS[o as usize].1, left))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_trader_comes_and_sells() {
        let mut g = Game::new(7, 64, 64);
        // own the portal
        let (px, py) = g.map.portals[0];
        for y in py - 2..py + 5 {
            for x in px - 2..px + 5 {
                if inb(x, y) && g.map.t[idx(x, y)].kind != Kind::Portal {
                    g.map.t[idx(x, y)].kind = Kind::Floor;
                }
                if inb(x, y) {
                    g.map.t[idx(x, y)].owner = Owner::Player;
                }
            }
        }
        g.trading.t = 0.01;
        g.update_traders(0.05);
        let (id, offer, _) = g.trading.here.expect("a trader came");
        let j = g.find(id).unwrap();
        assert!(!g.ents[j].creature(), "not one of the household");
        g.gold = 5000.0;
        let (gold, runes, wood) = (g.gold, g.rune_free, g.wood);
        assert!(g.buy_from_trader(j));
        assert!(g.gold < gold);
        match offer {
            0 => assert_eq!(g.rune_free, runes + 1),
            3 => assert!(g.wood > wood),
            _ => {}
        }
        assert!(g.trading.here.is_none() && !g.ents[j].alive, "he leaves");
    }
}